package com.sg.service.biz.app.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.app.req.*;
import com.sg.dto.biz.app.req.*;
import com.sg.dto.biz.app.res.*;
import com.sg.dto.integration.calc.QueryHighMidBaseWorkCycleDataListComReqDto;
import com.sg.dto.integration.calc.QueryHighMidBaseWorkCycleDataListComRespDto;
import com.sg.dto.integration.calc.StandardDataDto;
import com.sg.dto.integration.component.ObtainOutPutCurrentTreeOrderNumberComReqDto;
import com.sg.dto.integration.component.ObtainOutPutCurrentTreeOrderNumberComRespDto;
import com.sg.dto.integration.component.QueryConfItemMatchAnswerDetailComReqDto;
import com.sg.dto.integration.component.QueryConfItemMatchAnswerDetailComRespDto;
import com.sg.service.biz.app.*;
import com.sg.common.exception.Assert;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrapp.dal.po.mbg.*;
import com.wicket.okrcalc.integration.StandardDataService;
import com.wicket.okrcomponent.integration.ConfSchemeService;
import com.wicket.okrcomponent.integration.InterfaceModeService;
import com.wicket.okrframework.integration.InductionRecordService;
import com.wicket.okrframework.integration.OrgService;
import com.wicket.okrframework.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class TargetContComServiceImpl
        implements com.wicket.okrapp.biz.service.TargetContComService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MOmsEvaObjTargetCycleOsetService mOmsEvaObjTargetCycleOsetService;
    @Resource
    private MOmsTargetObjectiveService mOmsTargetObjectiveService;
    @Resource
    private ConfSchemeService confSchemeService;
    @Resource
    private TargetCycleService targetCycleService;
    @Resource
    private MOmsTargetObjectivePlanExtendService mOmsTargetObjectivePlanExtendService;
    @Resource
    private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
    @Resource
    private MOmsTargetAttributionCycleService mOmsTargetAttributionCycleService;
    @Resource
    private NbTargetContCom nbTargetContCom;
    @Resource
    private AchievementDockService achievementDockService;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private MOmsTargetCategoryService mOmsTargetCategoryService;
    @Resource
    private MOmsTaskService mOmsTaskService;
    @Resource
    private TargetContentService targetContentService;
    @Resource
    private MOmsEvaluationTemplateService mOmsEvaluationTemplateService;
    @Resource
    private VirtualOrgService virtualOrgService;
    @Resource
    private TargetCalcService targetCalcService;
    @Resource
    private OrgService orgService;
    @Resource
    private InductionRecordService inductionRecordService;
    @Resource
    private StandardDataService fwCalcStandardDataClient;
    @Resource
    private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
    @Resource
    private MOmsTargetService mOmsTargetService;
    @Resource
    private DashboardTargetContentService dashboardTargetContentService;
//@Resource
    //private MCustomFields4Service mCustomFields4Service;
//@Resource
    //private undefinedService undefinedService;


    /**
     * D3初始化目标周期目标设置(公共)[9410]
     * gen by moon at 7/17/2024, 1:24:51 AM
     */
    @Trace(operationName = "D3初始化目标周期目标设置(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementInitializeTargetCycleOsetComRespDto implementInitializeTargetCycleOsetCom(ImplementInitializeTargetCycleOsetComReqDto reqDto) {


        //virtualUsage D3准备入参：1查指标详情(公共)  67103
        QueryTargetObjectiveDetailComRespDto queryTargetObjectiveDetailComRespDto = null;
        QueryTargetObjectiveDetailComReqDto queryTargetObjectiveDetailComReqDto = new QueryTargetObjectiveDetailComReqDto();
        queryTargetObjectiveDetailComReqDto.setIsArchive("FALSE");//sourceId:1737961_1_67103
        queryTargetObjectiveDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1737962_1_67103
        if (reqDto != null) {
            queryTargetObjectiveDetailComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1737959_1_67103
            queryTargetObjectiveDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1737960_1_67103
        }

        /*D3准备入参：1查指标详情(公共)[9412]   */
        Assert.isNull(queryTargetObjectiveDetailComReqDto.getObjectiveId(), "D3初始化目标周期目标设置(公共)-D3准备入参：1查指标详情(公共)-指标ID不能为空", false);
        Assert.isNull(queryTargetObjectiveDetailComReqDto.getIsArchive(), "D3初始化目标周期目标设置(公共)-D3准备入参：1查指标详情(公共)-是否存档不能为空", false);
        Assert.isNull(queryTargetObjectiveDetailComReqDto.getSpaceId(), "D3初始化目标周期目标设置(公共)-D3准备入参：1查指标详情(公共)-创建于空间ID不能为空", false);
        queryTargetObjectiveDetailComRespDto = queryTargetObjectiveDetailCom(queryTargetObjectiveDetailComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage D2准备入参：3 查指标计算方式配置答案（公共）  67105
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("TARGET_VALUE_COUNT_TYPE");//CUSTOM_CONVENTION//sourceId:1737975_1_67105
        queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1737984_1_67105
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1737977_1_67105
        }

        /*D2准备入参：3 查指标计算方式配置答案（公共）[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(), "D3初始化目标周期目标设置(公共)-D2准备入参：3 查指标计算方式配置答案（公共）-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D3初始化目标周期目标设置(公共)-D2准备入参：3 查指标计算方式配置答案（公共）-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D3初始化目标周期目标设置(公共)-D2准备入参：3 查指标计算方式配置答案（公共）-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）  67107
        ObtainEvaObjTargetCycleComRespDto obtainEvaObjTargetCycleComRespDto = null;
        ObtainEvaObjTargetCycleComReqDto obtainEvaObjTargetCycleComReqDto = new ObtainEvaObjTargetCycleComReqDto();
        obtainEvaObjTargetCycleComReqDto.setIsParentCycle("TRUE");//sourceId:1738113_1_67107
        obtainEvaObjTargetCycleComReqDto.setIsArchive("FALSE");//sourceId:1738122_1_67107
        if (reqDto != null) {
            obtainEvaObjTargetCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1738108_1_67107
            obtainEvaObjTargetCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1738109_1_67107
            obtainEvaObjTargetCycleComReqDto.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1738111_1_67107
            obtainEvaObjTargetCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1738120_1_67107
        }

        /*D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）[9380]   */
        Assert.isNull(obtainEvaObjTargetCycleComReqDto.getEvaObjEntityId(), "D3初始化目标周期目标设置(公共)-D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）-被评对象内容表主键ID不能为空", false);
        Assert.isNull(obtainEvaObjTargetCycleComReqDto.getEvaObjTypeCode(), "D3初始化目标周期目标设置(公共)-D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）-被评对象类型编码不能为空", false);
        Assert.isNull(obtainEvaObjTargetCycleComReqDto.getTargetCycleContentId(), "D3初始化目标周期目标设置(公共)-D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）-关联目标内容ID不能为空", false);
        Assert.isNull(obtainEvaObjTargetCycleComReqDto.getIsParentCycle(), "D3初始化目标周期目标设置(公共)-D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）-是否父周期不能为空", false);
        Assert.isNull(obtainEvaObjTargetCycleComReqDto.getEvaluationTemplateId(), "D3初始化目标周期目标设置(公共)-D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）-冗余评价模板ID不能为空", false);
        Assert.isNull(obtainEvaObjTargetCycleComReqDto.getIsArchive(), "D3初始化目标周期目标设置(公共)-D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）-是否存档不能为空", false);
        obtainEvaObjTargetCycleComRespDto = targetCycleService.obtainEvaObjTargetCycleCom(obtainEvaObjTargetCycleComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage D3准备入参：4 查询指标被评目标周期列表(公共)  67106
        QueryEvaTargetCycleListComRespDto queryEvaTargetCycleListComRespDto = null;
        QueryEvaTargetCycleListComReqDto queryEvaTargetCycleListComReqDto = new QueryEvaTargetCycleListComReqDto();
        queryEvaTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:1738061_1_67106
        queryEvaTargetCycleListComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1738062_1_67106
        if (reqDto != null) {
            queryEvaTargetCycleListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1738052_1_67106
            queryEvaTargetCycleListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1738053_1_67106
            queryEvaTargetCycleListComReqDto.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1738055_1_67106
            queryEvaTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1738060_1_67106
        }

        /*D3准备入参：4 查询指标被评目标周期列表(公共)[9416]   */
        Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjEntityId(), "D3初始化目标周期目标设置(公共)-D3准备入参：4 查询指标被评目标周期列表(公共)-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjTypeCode(), "D3初始化目标周期目标设置(公共)-D3准备入参：4 查询指标被评目标周期列表(公共)-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaTargetCycleListComReqDto.getTargetCycleContentId(), "D3初始化目标周期目标设置(公共)-D3准备入参：4 查询指标被评目标周期列表(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaluationTemplateId(), "D3初始化目标周期目标设置(公共)-D3准备入参：4 查询指标被评目标周期列表(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaTargetCycleListComReqDto.getIsArchive(), "D3初始化目标周期目标设置(公共)-D3准备入参：4 查询指标被评目标周期列表(公共)-是否存档不能为空", false);
        Assert.isNull(queryEvaTargetCycleListComReqDto.getSpaceId(), "D3初始化目标周期目标设置(公共)-D3准备入参：4 查询指标被评目标周期列表(公共)-创建于空间ID不能为空", false);
        queryEvaTargetCycleListComRespDto = queryEvaTargetCycleListCom(queryEvaTargetCycleListComReqDto)/*vcase invoke 同服务,同domain*/;


        if ((reqDto != null && reqDto.getCalcBusinessScence() != null && reqDto.getCalcBusinessScence().equals("OKR_SUBJECT_PERSONAL") && !(queryTargetObjectiveDetailComRespDto != null && queryTargetObjectiveDetailComRespDto.getTargetValueType() != null && queryTargetObjectiveDetailComRespDto.getTargetValueType().equals("SUBJECTIVE_QUALITATIVE")) && obtainEvaObjTargetCycleComRespDto != null && obtainEvaObjTargetCycleComRespDto.getIndicatorKind() != null && obtainEvaObjTargetCycleComRespDto.getIndicatorKind().equals("KEY_RESULTS"))) {
            //if((D3初始化目标周期目标设置(公共).计算业务场景 等于 OKR责任主体个人 and D3准备入参：1查指标详情(公共).冗余指标业务类型 不等于 主观定性 and D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）.OKR目标属性 等于 关键成果KR))  67100

            QueryTargetCycleOsetDetailComRespDto queryTargetCycleOsetDetailComRespDto = null;
            if (obtainEvaObjTargetCycleComRespDto != null) {
                QueryTargetCycleOsetDetailComReqDto queryTargetCycleOsetDetailComReqDto = new QueryTargetCycleOsetDetailComReqDto();
                queryTargetCycleOsetDetailComReqDto.setIsArchive("FALSE");//sourceId:1738102_1_67108
                queryTargetCycleOsetDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1738103_1_67108
                if (obtainEvaObjTargetCycleComRespDto != null) {
                    queryTargetCycleOsetDetailComReqDto.setOkrPsEvaObjTargetCycleId(obtainEvaObjTargetCycleComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1738100_1_67108
                }
                if (reqDto != null) {
                    queryTargetCycleOsetDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1738101_1_67108
                }

                /*D3查询目标周期目标设置详情(公共)[9418]   */
                Assert.isNull(queryTargetCycleOsetDetailComReqDto.getEvaluationTemplateId(), "D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-冗余评价模板ID不能为空", false);
                Assert.isNull(queryTargetCycleOsetDetailComReqDto.getIsArchive(), "D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-是否存档不能为空", false);
                Assert.isNull(queryTargetCycleOsetDetailComReqDto.getSpaceId(), "D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-创建于空间ID不能为空", false);
                queryTargetCycleOsetDetailComRespDto = queryTargetCycleOsetDetailCom(queryTargetCycleOsetDetailComReqDto)/*vcase invoke 同服务,同domain*/;


            }
            if ((queryTargetCycleOsetDetailComRespDto != null && queryTargetCycleOsetDetailComRespDto.getEvaObjOsetId() == null)) {
                //if(D3查KR目标父周期目标设置(用于判断是否已存在).被评对象目标设置ID 值等于空 )  67109

                boolean bOOLEAN;
                if (queryEvaTargetCycleListComRespDto != null && queryTargetObjectiveDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto != null) {
                    List<OmsEvaObjTargetCycleOset> listOmsEvaObjTargetCycleOset = new ArrayList<>();
                    if (queryEvaTargetCycleListComRespDto != null && queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() != null && !CollectionUtil.isEmpty(queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList())) {
                        QueryTargetObjectiveDetailComRespDto finalQueryTargetObjectiveDetailComRespDto = queryTargetObjectiveDetailComRespDto;
                        QueryConfItemMatchAnswerDetailComRespDto finalQueryConfItemMatchAnswerDetailComRespDto = queryConfItemMatchAnswerDetailComRespDto;
                        listOmsEvaObjTargetCycleOset = //objList-to-objLists
                                queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().stream().map(item -> {
                                    OmsEvaObjTargetCycleOset elm = new OmsEvaObjTargetCycleOset();
                                    elm.setIsBeQuote("FALSE");//sourceId:349362_2_67110
                                    elm.setIsAlreadyQuote("FALSE");//sourceId:349363_2_67110
                                    if (item != null) {
                                        elm.setOkrPsEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:349345_2_67110
                                    }
                                    if (finalQueryTargetObjectiveDetailComRespDto != null) {
                                        elm.setUnit(finalQueryTargetObjectiveDetailComRespDto.getUnit());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349349_2_67110
                                        elm.setTargetValueType(finalQueryTargetObjectiveDetailComRespDto.getTargetValueType());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349351_2_67110
                                    }
                                    if (finalQueryConfItemMatchAnswerDetailComRespDto != null) {
                                        elm.setTargetValueCountType(finalQueryConfItemMatchAnswerDetailComRespDto.getEndValue());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349350_2_67110
                                    }
                                    if (reqDto != null) {
                                        elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349359_2_67110
                                        elm.setBatchCode(reqDto.getBatchCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349360_2_67110
                                        elm.setCreateBatchCode(reqDto.getBatchCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349361_2_67110
                                    }
                                    return elm;
                                }).collect(Collectors.toList());//objList-to-objLists//sourceId:1738068_1_67110
                    }

                    /*3-3-09-01批量增被评对象目标周期目标[4723]   */

                    bOOLEAN = mOmsEvaObjTargetCycleOsetService.batchAddEvaObjTargetCycleTarget(listOmsEvaObjTargetCycleOset)/*vcase invoke 本地 method 方法调用;*/;


                }
            }
        } else if ((reqDto != null && reqDto.getCalcBusinessScence() != null && reqDto.getCalcBusinessScence().equals("OKR_SUBJECT_DEPT") && obtainEvaObjTargetCycleComRespDto != null && obtainEvaObjTargetCycleComRespDto.getIsCustomObjective() != null && obtainEvaObjTargetCycleComRespDto.getIsCustomObjective().equals("TRUE"))) {
            //elseif((D3初始化目标周期目标设置(公共).计算业务场景 等于 OKR责任主体部门 and D3准备入参：5 查指标目标父周期ID（用于查询目标设置是否已存在）.是否自定义OKR目标 等于 是))  67101

//processBranchName:正常结束 ,processBranchId:67126

        } else if ((reqDto != null && reqDto.getCalcBusinessScence() != null && reqDto.getCalcBusinessScence().equals("EVA_PORTRAIT") && !(queryTargetObjectiveDetailComRespDto != null && queryTargetObjectiveDetailComRespDto.getTargetValueType() != null && queryTargetObjectiveDetailComRespDto.getTargetValueType().equals("SUBJECTIVE_QUALITATIVE")))) {
            //elseif((D3初始化目标周期目标设置(公共).计算业务场景 等于 评价画像 and D3准备入参：1查指标详情(公共).冗余指标业务类型 不等于 主观定性))  67102

            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
            if (obtainEvaObjTargetCycleComRespDto != null) {
                QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1 = new QueryConfItemMatchAnswerDetailComReqDto();
                queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("PERFORMANCE_WEIGHT_SETTING_OBJECT");//CUSTOM_CONVENTION//sourceId:1738032_1_67111
                queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:1738041_1_67111
                if (obtainEvaObjTargetCycleComRespDto != null) {
                    queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjId(obtainEvaObjTargetCycleComRespDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1738034_1_67111
                }

                /*D2查绩效权重目标设置对象配置答案[2486]   */
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjId(), "D3初始化目标周期目标设置(公共)-D2查绩效权重目标设置对象配置答案-开通对象ID不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(), "D3初始化目标周期目标设置(公共)-D2查绩效权重目标设置对象配置答案-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(), "D3初始化目标周期目标设置(公共)-D2查绩效权重目标设置对象配置答案-是否标准答案不能为空", false);
                queryConfItemMatchAnswerDetailComRespDto_2 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((queryConfItemMatchAnswerDetailComRespDto_2 != null && queryConfItemMatchAnswerDetailComRespDto_2.getEndValue() != null && queryConfItemMatchAnswerDetailComRespDto_2.getEndValue().equals("EVA_PORTRAIT") && reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("EVA_PORTRAIT"))) {
                //if((D2查绩效权重目标设置对象配置答案.答案值 等于 评价画像 and D3初始化目标周期目标设置(公共).被评对象类型编码 等于 评价画像))  67112

                QueryTargetCycleOsetDetailComRespDto queryTargetCycleOsetDetailComRespDto_2 = null;
                if (obtainEvaObjTargetCycleComRespDto != null) {
                    QueryTargetCycleOsetDetailComReqDto queryTargetCycleOsetDetailComReqDto_1 = new QueryTargetCycleOsetDetailComReqDto();
                    queryTargetCycleOsetDetailComReqDto_1.setIsArchive("FALSE");//sourceId:1738102_1_67118
                    queryTargetCycleOsetDetailComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1738103_1_67118
                    if (obtainEvaObjTargetCycleComRespDto != null) {
                        queryTargetCycleOsetDetailComReqDto_1.setEvaPortraitTargetCycleId(obtainEvaObjTargetCycleComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1738096_1_67118
                    }

                    /*D3查询目标周期目标设置详情(公共)[9418]   */
                    Assert.isNull(queryTargetCycleOsetDetailComReqDto_1.getEvaluationTemplateId(), "D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(queryTargetCycleOsetDetailComReqDto_1.getIsArchive(), "D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-是否存档不能为空", false);
                    Assert.isNull(queryTargetCycleOsetDetailComReqDto_1.getSpaceId(), "D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-创建于空间ID不能为空", false);
                    queryTargetCycleOsetDetailComRespDto_2 = queryTargetCycleOsetDetailCom(queryTargetCycleOsetDetailComReqDto_1)/*vcase invoke 同服务,同domain*/;


                }
                if ((queryTargetCycleOsetDetailComRespDto_2 != null && queryTargetCycleOsetDetailComRespDto_2.getEvaObjOsetId() == null)) {
                    //if(D3查询指标评价画像目标周期目标设置(用于判断是否已存在).被评对象目标设置ID 值等于空 )  67119

                    boolean bOOLEAN_1;
                    if (queryEvaTargetCycleListComRespDto != null && queryTargetObjectiveDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto != null) {
                        List<OmsEvaObjTargetCycleOset> listOmsEvaObjTargetCycleOset_1 = new ArrayList<>();
                        if (queryEvaTargetCycleListComRespDto != null && queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() != null && !CollectionUtil.isEmpty(queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList())) {
                            QueryTargetObjectiveDetailComRespDto finalQueryTargetObjectiveDetailComRespDto1 = queryTargetObjectiveDetailComRespDto;
                            QueryConfItemMatchAnswerDetailComRespDto finalQueryConfItemMatchAnswerDetailComRespDto1 = queryConfItemMatchAnswerDetailComRespDto;
                            listOmsEvaObjTargetCycleOset_1 = //objList-to-objLists
                                    queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().stream().map(item -> {
                                        OmsEvaObjTargetCycleOset elm = new OmsEvaObjTargetCycleOset();
                                        elm.setIsBeQuote("FALSE");//sourceId:349362_2_67120
                                        elm.setIsAlreadyQuote("FALSE");//sourceId:349363_2_67120
                                        if (item != null) {
                                            elm.setEvaPortraitTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:349341_2_67120
                                        }
                                        if (finalQueryTargetObjectiveDetailComRespDto1 != null) {
                                            elm.setUnit(finalQueryTargetObjectiveDetailComRespDto1.getUnit());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349349_2_67120
                                            elm.setTargetValueType(finalQueryTargetObjectiveDetailComRespDto1.getTargetValueType());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349351_2_67120
                                        }
                                        if (finalQueryConfItemMatchAnswerDetailComRespDto1 != null) {
                                            elm.setTargetValueCountType(finalQueryConfItemMatchAnswerDetailComRespDto1.getEndValue());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349350_2_67120
                                        }
                                        if (reqDto != null) {
                                            elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349359_2_67120
                                            elm.setBatchCode(reqDto.getBatchCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349360_2_67120
                                            elm.setCreateBatchCode(reqDto.getBatchCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349361_2_67120
                                        }
                                        return elm;
                                    }).collect(Collectors.toList());//objList-to-objLists//sourceId:1738068_1_67120
                        }

                        /*3-3-09-01批量增被评对象目标周期目标[4723]   */

                        bOOLEAN_1 = mOmsEvaObjTargetCycleOsetService.batchAddEvaObjTargetCycleTarget(listOmsEvaObjTargetCycleOset_1)/*vcase invoke 本地 method 方法调用;*/;


                    }
                }
            } else if ((queryConfItemMatchAnswerDetailComRespDto_2 != null && queryConfItemMatchAnswerDetailComRespDto_2.getEndValue() != null && queryConfItemMatchAnswerDetailComRespDto_2.getEndValue().equals("EVA_OBJECT") && reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("EVA_OBJECT"))) {
                //elseif((D2查绩效权重目标设置对象配置答案.答案值 等于 评价对象 and D3初始化目标周期目标设置(公共).被评对象类型编码 等于 评价对象))  67113

                QueryTargetCycleOsetDetailComRespDto queryTargetCycleOsetDetailComRespDto_3 = null;
                if (obtainEvaObjTargetCycleComRespDto != null) {
                    QueryTargetCycleOsetDetailComReqDto queryTargetCycleOsetDetailComReqDto_2 = new QueryTargetCycleOsetDetailComReqDto();
                    queryTargetCycleOsetDetailComReqDto_2.setIsArchive("FALSE");//sourceId:1738102_1_67121
                    queryTargetCycleOsetDetailComReqDto_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1738103_1_67121
                    if (obtainEvaObjTargetCycleComRespDto != null) {
                        queryTargetCycleOsetDetailComReqDto_2.setEvaObjTargetCycleId(obtainEvaObjTargetCycleComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1738097_1_67121
                    }
                    if (reqDto != null) {
                        queryTargetCycleOsetDetailComReqDto_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1738101_1_67121
                    }

                    /*D3查询目标周期目标设置详情(公共)[9418]   */
                    Assert.isNull(queryTargetCycleOsetDetailComReqDto_2.getEvaluationTemplateId(), "D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(queryTargetCycleOsetDetailComReqDto_2.getIsArchive(), "D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-是否存档不能为空", false);
                    Assert.isNull(queryTargetCycleOsetDetailComReqDto_2.getSpaceId(), "D3初始化目标周期目标设置(公共)-D3查询目标周期目标设置详情(公共)-创建于空间ID不能为空", false);
                    queryTargetCycleOsetDetailComRespDto_3 = queryTargetCycleOsetDetailCom(queryTargetCycleOsetDetailComReqDto_2)/*vcase invoke 同服务,同domain*/;


                }
                if ((queryTargetCycleOsetDetailComRespDto_3 != null && queryTargetCycleOsetDetailComRespDto_3.getEvaObjOsetId() == null)) {
                    //if(D3查询指标评价对象目标周期目标设置(用于判断是否已存在).被评对象目标设置ID 值等于空 )  67122

                    boolean bOOLEAN_2;
                    if (queryEvaTargetCycleListComRespDto != null && queryTargetObjectiveDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto != null) {
                        List<OmsEvaObjTargetCycleOset> listOmsEvaObjTargetCycleOset_2 = new ArrayList<>();
                        if (queryEvaTargetCycleListComRespDto != null && queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() != null && !CollectionUtil.isEmpty(queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList())) {
                            QueryTargetObjectiveDetailComRespDto finalQueryTargetObjectiveDetailComRespDto2 = queryTargetObjectiveDetailComRespDto;
                            QueryConfItemMatchAnswerDetailComRespDto finalQueryConfItemMatchAnswerDetailComRespDto2 = queryConfItemMatchAnswerDetailComRespDto;
                            listOmsEvaObjTargetCycleOset_2 = //objList-to-objLists
                                    queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().stream().map(item -> {
                                        OmsEvaObjTargetCycleOset elm = new OmsEvaObjTargetCycleOset();
                                        elm.setIsBeQuote("FALSE");//sourceId:349362_2_67123
                                        elm.setIsAlreadyQuote("FALSE");//sourceId:349363_2_67123
                                        if (item != null) {
                                            elm.setEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:349342_2_67123
                                        }
                                        if (finalQueryTargetObjectiveDetailComRespDto2 != null) {
                                            elm.setUnit(finalQueryTargetObjectiveDetailComRespDto2.getUnit());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349349_2_67123
                                            elm.setTargetValueType(finalQueryTargetObjectiveDetailComRespDto2.getTargetValueType());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349351_2_67123
                                        }
                                        if (finalQueryConfItemMatchAnswerDetailComRespDto2 != null) {
                                            elm.setTargetValueCountType(finalQueryConfItemMatchAnswerDetailComRespDto2.getEndValue());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349350_2_67123
                                        }
                                        if (reqDto != null) {
                                            elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349359_2_67123
                                            elm.setBatchCode(reqDto.getBatchCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349360_2_67123
                                            elm.setCreateBatchCode(reqDto.getBatchCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:349361_2_67123
                                        }
                                        return elm;
                                    }).collect(Collectors.toList());//objList-to-objLists//sourceId:1738068_1_67123
                        }

                        /*3-3-09-01批量增被评对象目标周期目标[4723]   */

                        bOOLEAN_2 = mOmsEvaObjTargetCycleOsetService.batchAddEvaObjTargetCycleTarget(listOmsEvaObjTargetCycleOset_2)/*vcase invoke 本地 method 方法调用;*/;


                    }
                }
            } else {
                //else  67116

//异常结束 67117
                throw new BizException("C00028", "对不起，没有数据！！", false);
            }
        }
        ImplementInitializeTargetCycleOsetComRespDto retData = new ImplementInitializeTargetCycleOsetComRespDto();


        return retData;
    }

    /**
     * D3查询目标周期目标设置详情(公共)[9418]
     * gen by moon at 4/19/2024, 11:00:22 PM
     */
    @Trace(operationName = "D3查询目标周期目标设置详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryTargetCycleOsetDetailComRespDto queryTargetCycleOsetDetailCom(QueryTargetCycleOsetDetailComReqDto reqDto) {


        OmsEvaObjTargetCycleOset omsEvaObjTargetCycleOset_1 = null;
//步骤0: 3-3-09-01查询目标周期目标设置详情 - queryTargetCycleOsetDetail
        OmsEvaObjTargetCycleOset omsEvaObjTargetCycleOset = null;
        QueryTargetCycleOsetDetailReq queryTargetCycleOsetDetailReq = new QueryTargetCycleOsetDetailReq();
        if (reqDto != null) {
            queryTargetCycleOsetDetailReq.setEvaPortraitTargetCycleId(reqDto.getEvaPortraitTargetCycleId());//SimpleFieldAssign//sourceId:1738078_1
            queryTargetCycleOsetDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1738079_1
            queryTargetCycleOsetDetailReq.setMLevelEvaObjTargetCycleId(reqDto.getMLevelEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1738080_1
            queryTargetCycleOsetDetailReq.setOkrDptEvaObjTargetCycleId(reqDto.getOkrDptEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1738081_1
            queryTargetCycleOsetDetailReq.setOkrPsEvaObjTargetCycleId(reqDto.getOkrPsEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1738082_1
            queryTargetCycleOsetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1738083_1
            queryTargetCycleOsetDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1738084_1
            queryTargetCycleOsetDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1738085_1
        }

        /*3-3-09-01查询目标周期目标设置详情[9417]   */
        Assert.isNull(queryTargetCycleOsetDetailReq.getEvaluationTemplateId(), "D3查询目标周期目标设置详情(公共)-3-3-09-01查询目标周期目标设置详情-冗余评价模板ID不能为空", false);
        omsEvaObjTargetCycleOset = mOmsEvaObjTargetCycleOsetService.queryTargetCycleOsetDetail(queryTargetCycleOsetDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsEvaObjTargetCycleOset_1 = omsEvaObjTargetCycleOset;

        QueryTargetCycleOsetDetailComRespDto retData = new QueryTargetCycleOsetDetailComRespDto();
        if (omsEvaObjTargetCycleOset_1 != null) {
            retData.setEvaObjOsetId(omsEvaObjTargetCycleOset_1.getEvaObjOsetId());//SimpleFieldAssign//sourceId:1738095_1
        }


        return retData;
    }

    /**
     * D3查询被评目标周期列表(公共)[9416]
     * gen by moon at 7/17/2024, 1:24:53 AM
     */
    @Trace(operationName = "D3查询被评目标周期列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryEvaTargetCycleListComRespDto queryEvaTargetCycleListCom(QueryEvaTargetCycleListComReqDto reqDto) {


        List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_1 = new ArrayList<>();
//步骤0: 3-3-09查询被评目标周期列表 - queryEvaTargetCycleList
        List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle = new ArrayList<>();
        QueryEvaTargetCycleListReq queryEvaTargetCycleListReq = new QueryEvaTargetCycleListReq();
        if (reqDto != null) {
            queryEvaTargetCycleListReq.setParentEvaObjTargetCycleId(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1771028_1
            queryEvaTargetCycleListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1738008_1
            queryEvaTargetCycleListReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1738009_1
            queryEvaTargetCycleListReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1738010_1
            queryEvaTargetCycleListReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1738011_1
            queryEvaTargetCycleListReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1738012_1
            queryEvaTargetCycleListReq.setIsParentCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1738013_1
            queryEvaTargetCycleListReq.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1738014_1
            queryEvaTargetCycleListReq.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1738015_1
            queryEvaTargetCycleListReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1774416_1
            queryEvaTargetCycleListReq.setIsReached(reqDto.getIsReached());//SimpleFieldAssign//sourceId:1771072_1
            queryEvaTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1738016_1
            queryEvaTargetCycleListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1738017_1
            queryEvaTargetCycleListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1774419_1
            queryEvaTargetCycleListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1738018_1
        }

        /*3-3-09查询被评目标周期列表[9415]   */
        Assert.isNull(queryEvaTargetCycleListReq.getEvaluationTemplateId(), "D3查询被评目标周期列表(公共)-3-3-09查询被评目标周期列表-冗余评价模板ID不能为空", false);
        listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaTargetCycleList(queryEvaTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsEvaluationObjectTargetCycle_1 = listOmsEvaluationObjectTargetCycle;

        QueryEvaTargetCycleListComRespDto retData = new QueryEvaTargetCycleListComRespDto();
        retData.setEvaObjTargetCycleList(listOmsEvaluationObjectTargetCycle_1.stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1738031_1


        return retData;
    }

    /**
     * D3查询指标详情(公共)[9412]
     * gen by moon at 8/31/2024, 1:03:25 PM
     */
    @Trace(operationName = "D3查询指标详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryTargetObjectiveDetailComRespDto queryTargetObjectiveDetailCom(QueryTargetObjectiveDetailComReqDto reqDto) {


        OmsTargetObjective omsTargetObjective_1 = null;
//步骤0: 3-3-03查询指标详情 - queryTargetObjectiveDetail
        OmsTargetObjective omsTargetObjective = null;
        QueryTargetObjectiveDetailReq queryTargetObjectiveDetailReq = new QueryTargetObjectiveDetailReq();
        if (reqDto != null) {
            queryTargetObjectiveDetailReq.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1737920_1
            queryTargetObjectiveDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1737921_1
            queryTargetObjectiveDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1737922_1
            queryTargetObjectiveDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1797557_1
            queryTargetObjectiveDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1737923_1
        }

        /*3-3-03查询指标详情[9411]   */

        omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjectiveDetail(queryTargetObjectiveDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsTargetObjective_1 = omsTargetObjective;

        QueryTargetObjectiveDetailComRespDto retData = new QueryTargetObjectiveDetailComRespDto();
        if (omsTargetObjective_1 != null) {
            retData.setObjectiveId(omsTargetObjective_1.getObjectiveId());//SimpleFieldAssign//sourceId:1737933_1
            retData.setObjectiveName(omsTargetObjective_1.getObjectiveName());//SimpleFieldAssign//sourceId:1992446_1
            retData.setObjectiveShortName(omsTargetObjective_1.getObjectiveShortName());//SimpleFieldAssign//sourceId:1992447_1
            retData.setTargetValueType(omsTargetObjective_1.getTargetValueType());//SimpleFieldAssign//sourceId:1737934_1
            retData.setIsLeft(omsTargetObjective_1.getIsLeft());//SimpleFieldAssign//sourceId:1737935_1
            retData.setUnit(omsTargetObjective_1.getUnit());//SimpleFieldAssign//sourceId:1737936_1
            retData.setDigitalUnit(omsTargetObjective_1.getDigitalUnit());//SimpleFieldAssign//sourceId:1737937_1
            retData.setIsLastObjective(omsTargetObjective_1.getIsLastObjective());//SimpleFieldAssign//sourceId:1777707_1
            retData.setLevelNumber(omsTargetObjective_1.getLevelNumber());//SimpleFieldAssign//sourceId:1797566_1
            retData.setParentObjectiveId(omsTargetObjective_1.getParentObjectiveId());//SimpleFieldAssign//sourceId:1797975_1
            retData.setRootObjectiveId(omsTargetObjective_1.getRootObjectiveId());//SimpleFieldAssign//sourceId:1797567_1
            retData.setRootTargetCategoryId(omsTargetObjective_1.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1797568_1
            retData.setTargetId(omsTargetObjective_1.getTargetId());//SimpleFieldAssign//sourceId:1797569_1
        }


        return retData;
    }

    /**
     * D3分析对齐时间与是否对齐(公共)[9574]
     * gen by moon at 5/13/2024, 11:21:07 PM
     */
    @Trace(operationName = "D3分析对齐时间与是否对齐(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisAlignmentTimeAndIsAlignmentComRespDto analysisAlignmentTimeAndIsAlignmentCom(AnalysisAlignmentTimeAndIsAlignmentComReqDto reqDto) {


        ImplementFiveReceivingFieldRespDto receptionServiceRes_3 = null;
//virtualUsage M3接收入参字段  68381
        //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
        ImplementFiveReceivingFieldReqDto receptionServiceReq = new ImplementFiveReceivingFieldReqDto();
        receptionServiceReq.setCustomField1("TRUE");//CUSTOM_CONVENTION//sourceId:1797142_1_68381
        receptionServiceReq.setCustomField2("FALSE");//CUSTOM_CONVENTION//sourceId:1797144_1_68381
        if (reqDto != null) {
            receptionServiceReq.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1796761_1_68381
            receptionServiceReq.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1796763_1_68381
        }

        /*M3接收入参字段[8467]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getPlanStartTime(), "D3分析对齐时间与是否对齐(公共)-M3接收入参字段-计划开始时间不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField1(), "D3分析对齐时间与是否对齐(公共)-M3接收入参字段-自定义字段1不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField2(), "D3分析对齐时间与是否对齐(公共)-M3接收入参字段-自定义字段2不能为空", false);
        receptionServiceRes = nbTargetContCom.implementFiveReceivingField(receptionServiceReq);


        if ((reqDto != null && reqDto.getObjectiveId() != null)) {
            //if(D3分析对齐时间与是否对齐(公共).对齐指标ID 值不等于空 )  68380

//ModelCode: receptionService
            ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
            ImplementFiveReceivingFieldReqDto receptionServiceReq_1 = new ImplementFiveReceivingFieldReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_1.setIsAlignment(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1797141_1_68382
            }
            if (reqDto != null) {
                receptionServiceReq_1.setAlignmentTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1797140_1_68382
            }

            /*M3接收对齐时间出参[8467]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getIsAlignment(), "D3分析对齐时间与是否对齐(公共)-M3接收对齐时间出参-是否对齐不能为空", false);
            receptionServiceRes_2 = nbTargetContCom.implementFiveReceivingField(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        } else if ((reqDto != null && reqDto.getObjectiveId() == null)) {
            //elseif(D3分析对齐时间与是否对齐(公共).对齐指标ID 值等于空 )  68383

//ModelCode: receptionService
            ImplementFiveReceivingFieldRespDto receptionServiceRes_4 = null;
            ImplementFiveReceivingFieldReqDto receptionServiceReq_2 = new ImplementFiveReceivingFieldReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_2.setIsAlignment(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1797141_1_68384
            }

            /*M3接收对齐时间出参[8467]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getIsAlignment(), "D3分析对齐时间与是否对齐(公共)-M3接收对齐时间出参-是否对齐不能为空", false);
            receptionServiceRes_4 = nbTargetContCom.implementFiveReceivingField(receptionServiceReq_2);


            receptionServiceRes_3 = receptionServiceRes_4;
        }
        AnalysisAlignmentTimeAndIsAlignmentComRespDto retData = new AnalysisAlignmentTimeAndIsAlignmentComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setIsAlignment(receptionServiceRes_3.getIsAlignment());//SimpleFieldAssign//sourceId:1797146_1
            retData.setAlignmentTime(receptionServiceRes_3.getAlignmentTime());//SimpleFieldAssign//sourceId:1797147_1
        }


        return retData;
    }

    /**
     * D3分析对齐指标关联信息(公共)[9575]
     * gen by moon at 5/13/2024, 11:21:22 PM
     */
    @Trace(operationName = "D3分析对齐指标关联信息(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisAlignmentObjectiveRelevancyInfoComRespDto analysisAlignmentObjectiveRelevancyInfoCom(AnalysisAlignmentObjectiveRelevancyInfoComReqDto reqDto) {


        AnalysisAlignmentTimeAndIsAlignmentComRespDto analysisAlignmentTimeAndIsAlignmentComRespDto_1 = null;
        ImplementFiveReceivingFieldRespDto receptionServiceRes_1 = null;
//virtualUsage D3分析对齐时间与是否对齐(公共)  68385
        AnalysisAlignmentTimeAndIsAlignmentComRespDto analysisAlignmentTimeAndIsAlignmentComRespDto = null;
        AnalysisAlignmentTimeAndIsAlignmentComReqDto analysisAlignmentTimeAndIsAlignmentComReqDto = new AnalysisAlignmentTimeAndIsAlignmentComReqDto();
        if (reqDto != null) {
            analysisAlignmentTimeAndIsAlignmentComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1797148_1_68385
            analysisAlignmentTimeAndIsAlignmentComReqDto.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1797149_1_68385
        }

        /*D3分析对齐时间与是否对齐(公共)[9574]   */
        Assert.isNull(analysisAlignmentTimeAndIsAlignmentComReqDto.getPlanStartTime(), "D3分析对齐指标关联信息(公共)-D3分析对齐时间与是否对齐(公共)-计划开始时间不能为空", false);
        analysisAlignmentTimeAndIsAlignmentComRespDto = analysisAlignmentTimeAndIsAlignmentCom(analysisAlignmentTimeAndIsAlignmentComReqDto)/*vcase invoke 同服务,同domain*/;


        analysisAlignmentTimeAndIsAlignmentComRespDto_1 = analysisAlignmentTimeAndIsAlignmentComRespDto;
        if ((reqDto != null && reqDto.getObjectiveId() != null)) {
            //if(D3分析对齐指标关联信息(公共).对齐指标ID 值不等于空 )  68386

            QueryObjtiveExtSetDetailComRespDto queryObjtiveExtSetDetailComRespDto = null;
            QueryObjtiveExtSetDetailComReqDto queryObjtiveExtSetDetailComReqDto = new QueryObjtiveExtSetDetailComReqDto();
            queryObjtiveExtSetDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1797530_1_68387
            if (reqDto != null) {
                queryObjtiveExtSetDetailComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1797528_1_68387
                queryObjtiveExtSetDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1797531_1_68387
            }

            /*D3查对齐指标OKR属性（用于判断分析关联父级目标内容）[9247]   */
            Assert.isNull(queryObjtiveExtSetDetailComReqDto.getObjectiveId(), "D3分析对齐指标关联信息(公共)-D3查对齐指标OKR属性（用于判断分析关联父级目标内容）-归属指标ID不能为空", false);
            Assert.isNull(queryObjtiveExtSetDetailComReqDto.getSubjectLifeCycle(), "D3分析对齐指标关联信息(公共)-D3查对齐指标OKR属性（用于判断分析关联父级目标内容）-主体生命周期不能为空", false);
            Assert.isNull(queryObjtiveExtSetDetailComReqDto.getSpaceId(), "D3分析对齐指标关联信息(公共)-D3查对齐指标OKR属性（用于判断分析关联父级目标内容）-创建于空间ID不能为空", false);
            queryObjtiveExtSetDetailComRespDto = achievementDockService.queryObjtiveExtSetDetailCom(queryObjtiveExtSetDetailComReqDto)/*vcase invoke isSameApp*/;


            QueryTargetObjectiveDetailComRespDto queryTargetObjectiveDetailComRespDto = null;
            QueryTargetObjectiveDetailComReqDto queryTargetObjectiveDetailComReqDto = new QueryTargetObjectiveDetailComReqDto();
            queryTargetObjectiveDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1797570_1_68395
            if (reqDto != null) {
                queryTargetObjectiveDetailComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1797547_1_68395
                queryTargetObjectiveDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1797550_1_68395
            }

            /*D3查询对齐指标详情(公共)[9412]   */
            Assert.isNull(queryTargetObjectiveDetailComReqDto.getObjectiveId(), "D3分析对齐指标关联信息(公共)-D3查询对齐指标详情(公共)-指标ID不能为空", false);
            Assert.isNull(queryTargetObjectiveDetailComReqDto.getSubjectLifeCycle(), "D3分析对齐指标关联信息(公共)-D3查询对齐指标详情(公共)-主体生命周期不能为空", false);
            Assert.isNull(queryTargetObjectiveDetailComReqDto.getSpaceId(), "D3分析对齐指标关联信息(公共)-D3查询对齐指标详情(公共)-创建于空间ID不能为空", false);
            queryTargetObjectiveDetailComRespDto = queryTargetObjectiveDetailCom(queryTargetObjectiveDetailComReqDto)/*vcase invoke 同服务,同domain*/;


            if ((queryObjtiveExtSetDetailComRespDto != null && queryObjtiveExtSetDetailComRespDto.getIndicatorKind() != null && queryObjtiveExtSetDetailComRespDto.getIndicatorKind().equals("KEY_RESULTS"))) {
                //if(D3查对齐指标OKR属性（用于判断分析关联父级目标内容）.OKR目标属性 等于 关键成果KR)  68388

//ModelCode: receptionService
                ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
                if (queryTargetObjectiveDetailComRespDto != null) {
                    ImplementFiveReceivingFieldReqDto receptionServiceReq = new ImplementFiveReceivingFieldReqDto();
                    if (queryTargetObjectiveDetailComRespDto != null) {
                        receptionServiceReq.setRootObjectiveId(queryTargetObjectiveDetailComRespDto.getParentObjectiveId());//SimpleFieldAssign//sourceId:1797965_1_68393
                        receptionServiceReq.setTargetId(queryTargetObjectiveDetailComRespDto.getTargetId());//SimpleFieldAssign//sourceId:1797967_1_68393
                    }

                    /*M3接收任务对齐目标关联信息出参[8467]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq.getRootObjectiveId(), "D3分析对齐指标关联信息(公共)-M3接收任务对齐目标关联信息出参-冗余对齐目标O或一级指标ID不能为空", false);
                    Assert.isNull(receptionServiceReq.getTargetId(), "D3分析对齐指标关联信息(公共)-M3接收任务对齐目标关联信息出参-冗余对齐目标ID不能为空", false);
                    receptionServiceRes = nbTargetContCom.implementFiveReceivingField(receptionServiceReq);


                    receptionServiceRes_1 = receptionServiceRes;
                }
            } else if ((queryObjtiveExtSetDetailComRespDto != null && queryObjtiveExtSetDetailComRespDto.getIndicatorKind() != null && queryObjtiveExtSetDetailComRespDto.getIndicatorKind().equals("OBJECTIVES"))) {
                //elseif(D3查对齐指标OKR属性（用于判断分析关联父级目标内容）.OKR目标属性 等于 目标O)  68390

//ModelCode: receptionService
                ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
                if (queryTargetObjectiveDetailComRespDto != null) {
                    ImplementFiveReceivingFieldReqDto receptionServiceReq_1 = new ImplementFiveReceivingFieldReqDto();
                    if (queryTargetObjectiveDetailComRespDto != null) {
                        receptionServiceReq_1.setRootObjectiveId(queryTargetObjectiveDetailComRespDto.getRootObjectiveId());//SimpleFieldAssign//sourceId:1797965_1_68394
                        receptionServiceReq_1.setRootTargetCategoryId(queryTargetObjectiveDetailComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1797966_1_68394
                        receptionServiceReq_1.setTargetId(queryTargetObjectiveDetailComRespDto.getTargetId());//SimpleFieldAssign//sourceId:1797967_1_68394
                    }

                    /*M3接收任务对齐目标关联信息出参[8467]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_1.getRootObjectiveId(), "D3分析对齐指标关联信息(公共)-M3接收任务对齐目标关联信息出参-冗余对齐目标O或一级指标ID不能为空", false);
                    Assert.isNull(receptionServiceReq_1.getTargetId(), "D3分析对齐指标关联信息(公共)-M3接收任务对齐目标关联信息出参-冗余对齐目标ID不能为空", false);
                    receptionServiceRes_2 = nbTargetContCom.implementFiveReceivingField(receptionServiceReq_1);


                    receptionServiceRes_1 = receptionServiceRes_2;
                }
            }
        }
        AnalysisAlignmentObjectiveRelevancyInfoComRespDto retData = new AnalysisAlignmentObjectiveRelevancyInfoComRespDto();
        if (analysisAlignmentTimeAndIsAlignmentComRespDto_1 != null) {
            retData.setIsAlignment(analysisAlignmentTimeAndIsAlignmentComRespDto_1.getIsAlignment());//SimpleFieldAssign//sourceId:1797977_1
            retData.setAlignmentTime(analysisAlignmentTimeAndIsAlignmentComRespDto_1.getAlignmentTime());//SimpleFieldAssign//sourceId:1797978_1
        }
        if (receptionServiceRes_1 != null) {
            retData.setRootObjectiveId(receptionServiceRes_1.getRootObjectiveId());//SimpleFieldAssign//sourceId:1797979_1
            retData.setRootTargetCategoryId(receptionServiceRes_1.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1797980_1
            retData.setTargetId(receptionServiceRes_1.getTargetId());//SimpleFieldAssign//sourceId:1797981_1
        }


        return retData;
    }

    /**
     * D3批量改目标内容编号(公共)[9586]
     * gen by moon at 5/16/2024, 8:53:24 PM
     */
    @Trace(operationName = "D3批量改目标内容编号(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchUpdateTargetContentNumberComRespDto batchUpdateTargetContentNumberCom(BatchUpdateTargetContentNumberComReqDto reqDto) {


        //步骤0: 3-3-09查被评对象目标周期列表（根据周期时间范围） - queryEvaObjTargetCycleList
        List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle = new ArrayList<>();
        QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq = new QueryEvaObjTargetCycleListReq();
        queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:1801867_1
        if (reqDto != null) {
            queryEvaObjTargetCycleListReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1801865_1
            queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1801866_1
        }

        /*3-3-09查被评对象目标周期列表（根据周期时间范围）[2190]   */
        Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentId(), "D3批量改目标内容编号(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(), "D3批量改目标内容编号(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(), "D3批量改目标内容编号(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-是否存档不能为空", false);
        listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 3-3-09-01批量改被评对象目标周期 - batchUpdateEvaObjTargetCycle
        boolean bOOLEAN;
        if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle.size() > 0) {
            List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_2 = new ArrayList<>();
            if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)) {
                listOmsEvaluationObjectTargetCycle_2 = //objList-to-objLists
                        listOmsEvaluationObjectTargetCycle.stream().map(item -> {
                            OmsEvaluationObjectTargetCycle elm = new OmsEvaluationObjectTargetCycle();
                            elm.setEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:363020_2
                            elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:363023_2
                            elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:363024_2
                            if (reqDto != null) {
                                elm.setTargetContentNumber(reqDto.getTargetContentNumber());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:363022_2
                            }
                            return elm;
                        }).collect(Collectors.toList());//objList-to-objLists//sourceId:1801870_1
            }

            /*3-3-09-01批量改被评对象目标周期[2664]   */

            bOOLEAN = mOmsEvaluationObjectTargetCycleService.batchUpdateEvaObjTargetCycle(listOmsEvaluationObjectTargetCycle_2)/*vcase invoke 本地 method 方法调用;*/;


        }

        BatchUpdateTargetContentNumberComRespDto retData = new BatchUpdateTargetContentNumberComRespDto();


        return retData;
    }

    /**
     * D3执行初始化目标分类编号(公共)[9587]
     * gen by moon at 5/17/2024, 2:19:24 AM
     */
    @Trace(operationName = "D3执行初始化目标分类编号(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementInitializeCategoryNumberComRespDto implementInitializeCategoryNumberCom(ImplementInitializeCategoryNumberComReqDto reqDto) {


        ImplementFiveReceivingFieldRespDto receptionServiceRes_3 = null;
        if ((reqDto != null && reqDto.getTargetCategoryNumber() == null)) {
            //if(D3执行初始化目标分类编号(公共).目标分类编号 值等于空 )  68483

//ModelCode: receptionService
            ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
            ImplementFiveReceivingFieldReqDto receptionServiceReq = new ImplementFiveReceivingFieldReqDto();
            receptionServiceReq.setTargetCategoryNumber("TC" + CommonFunctionHelper.getUid());//AUTO_GENERATE//sourceId:1803448_1_68484

            /*M3自定生成目标分类编号[8467]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getTargetCategoryNumber(), "D3执行初始化目标分类编号(公共)-M3自定生成目标分类编号-目标分类编号不能为空", false);
            receptionServiceRes = nbTargetContCom.implementFiveReceivingField(receptionServiceReq);


//ModelCode: receptionService
            ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
            ImplementFiveReceivingFieldReqDto receptionServiceReq_1 = new ImplementFiveReceivingFieldReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_1.setTargetCategoryNumber(receptionServiceRes.getTargetCategoryNumber());//SimpleFieldAssign//sourceId:1803445_1_68485
            }

            /*M3接收目标分类编号出参[8467]  用于特殊方法接收上游入参。 */

            receptionServiceRes_2 = nbTargetContCom.implementFiveReceivingField(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        } else if ((reqDto != null && reqDto.getTargetCategoryNumber() != null)) {
            //elseif(D3执行初始化目标分类编号(公共).目标分类编号 值不等于空 )  68486

//ModelCode: receptionService
            ImplementFiveReceivingFieldRespDto receptionServiceRes_4 = null;
            ImplementFiveReceivingFieldReqDto receptionServiceReq_2 = new ImplementFiveReceivingFieldReqDto();
            if (reqDto != null) {
                receptionServiceReq_2.setTargetCategoryNumber(reqDto.getTargetCategoryNumber());//SimpleFieldAssign//sourceId:1803445_1_68487
            }

            /*M3接收目标分类编号出参[8467]  用于特殊方法接收上游入参。 */

            receptionServiceRes_4 = nbTargetContCom.implementFiveReceivingField(receptionServiceReq_2);


            receptionServiceRes_3 = receptionServiceRes_4;
        }
        ImplementInitializeCategoryNumberComRespDto retData = new ImplementInitializeCategoryNumberComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setTargetCategoryNumber(receptionServiceRes_3.getTargetCategoryNumber());//SimpleFieldAssign//sourceId:1803451_1
        }


        return retData;
    }

    /**
     * D3查询目标周期祖先数据源列表[9588]
     * gen by moon at 5/17/2024, 2:19:28 AM
     */
    @Trace(operationName = "D3查询目标周期祖先数据源列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryTargetCycleAncestorDataOriginListRespDto queryTargetCycleAncestorDataOriginList(QueryTargetCycleAncestorDataOriginListReqDto reqDto) {


        List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_1 = new ArrayList<>();
//步骤0: M3-执行第五接收字段（特殊方法） - implementFiveReceivingField
        //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
        ImplementFiveReceivingFieldReqDto receptionServiceReq = new ImplementFiveReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1803845_1
            receptionServiceReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1803847_1
            receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1803846_1
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1803848_1
        }

        /*M3接收入参字段[8467]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaObjTargetCycleCode(), "D3查询目标周期祖先数据源列表-M3接收入参字段-被评对象目标周期标识不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaObjEntityId(), "D3查询目标周期祖先数据源列表-M3接收入参字段-被评对象内容表主键ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaObjTypeCode(), "D3查询目标周期祖先数据源列表-M3接收入参字段-被评对象类型编码不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D3查询目标周期祖先数据源列表-M3接收入参字段-冗余评价模板ID不能为空", false);
        receptionServiceRes = nbTargetContCom.implementFiveReceivingField(receptionServiceReq);


//步骤1: D3-查询找祖先列表(公共) - queryLookAncestorNodeListCom
        QueryLookAncestorNodeListComRespDto queryLookAncestorNodeListComRespDto = null;
        QueryLookAncestorNodeListComReqDto queryLookAncestorNodeListComReqDto = new QueryLookAncestorNodeListComReqDto();
        if (reqDto != null) {
            queryLookAncestorNodeListComReqDto.setComCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1803858_1
        }

        /*D3-查询找祖先列表(公共)[5833]   */
        Assert.isNull(queryLookAncestorNodeListComReqDto.getComCode(), "D3查询目标周期祖先数据源列表-D3-查询找祖先列表(公共)-通用编码标识不能为空", false);
        queryLookAncestorNodeListComRespDto = interfaceModeService.queryLookAncestorNodeListCom(queryLookAncestorNodeListComReqDto)/*vcase invoke isSameApp*/;


//步骤2: 3-3-09批量查询目标周期by内容标识 - batchQueryTargetCycleByContentCodes
        List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle = new ArrayList<>();
        if (queryLookAncestorNodeListComRespDto != null) {
            BatchQueryTargetCycleByContentCodesReq batchQueryTargetCycleByContentCodesReq = new BatchQueryTargetCycleByContentCodesReq();
            batchQueryTargetCycleByContentCodesReq.setIsParentCycle("TRUE");//sourceId:1803895_1
            batchQueryTargetCycleByContentCodesReq.setIsArchive("FALSE");//sourceId:1803900_1
            batchQueryTargetCycleByContentCodesReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1803898_1
            if (queryLookAncestorNodeListComRespDto != null) {
                batchQueryTargetCycleByContentCodesReq.setEvaObjTargetCycleList(queryLookAncestorNodeListComRespDto.getLookAncestorNodeList());//list-field-assign//sourceId:1803892_1
            }
            if (reqDto != null) {
                batchQueryTargetCycleByContentCodesReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1803893_1
                batchQueryTargetCycleByContentCodesReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1803894_1
                batchQueryTargetCycleByContentCodesReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1803896_1
            }

            /*3-3-09批量查询目标周期by内容标识[9589]   */
            Assert.isNull(batchQueryTargetCycleByContentCodesReq.getEvaObjEntityId(), "D3查询目标周期祖先数据源列表-3-3-09批量查询目标周期by内容标识-被评对象内容表主键ID不能为空", false);
            Assert.isNull(batchQueryTargetCycleByContentCodesReq.getEvaObjTypeCode(), "D3查询目标周期祖先数据源列表-3-3-09批量查询目标周期by内容标识-被评对象类型编码不能为空", false);
            Assert.isNull(batchQueryTargetCycleByContentCodesReq.getIsParentCycle(), "D3查询目标周期祖先数据源列表-3-3-09批量查询目标周期by内容标识-是否父周期不能为空", false);
            Assert.isNull(batchQueryTargetCycleByContentCodesReq.getEvaluationTemplateId(), "D3查询目标周期祖先数据源列表-3-3-09批量查询目标周期by内容标识-冗余评价模板ID不能为空", false);
            Assert.isNull(batchQueryTargetCycleByContentCodesReq.getIsArchive(), "D3查询目标周期祖先数据源列表-3-3-09批量查询目标周期by内容标识-是否存档不能为空", false);
            Assert.isNull(batchQueryTargetCycleByContentCodesReq.getSpaceId(), "D3查询目标周期祖先数据源列表-3-3-09批量查询目标周期by内容标识-创建于空间ID不能为空", false);
            listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.batchQueryTargetCycleByContentCodes(batchQueryTargetCycleByContentCodesReq)/*vcase invoke 本地 method 方法调用;*/;


            listOmsEvaluationObjectTargetCycle_1 = listOmsEvaluationObjectTargetCycle;
        }

        QueryTargetCycleAncestorDataOriginListRespDto retData = new QueryTargetCycleAncestorDataOriginListRespDto();
        retData.setEvaObjTargetCycleList(listOmsEvaluationObjectTargetCycle_1.stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1803901_1


        return retData;
    }

    /**
     * D3执行刷全模板目标内容树排序[9592]
     * gen by moon at 5/17/2024, 11:30:44 PM
     */
    @Trace(operationName = "D3执行刷全模板目标内容树排序")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementBrushTempTargetContTreeOrderNumRespDto implementBrushTempTargetContTreeOrderNum(ImplementBrushTempTargetContTreeOrderNumReqDto reqDto) {


        //virtualUsage 3-3-09查目标周期（标识排序小到大）列表  68501
        List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle = new ArrayList<>();
        QueryTargetCycleCodeOrderStoMaxListReq queryTargetCycleCodeOrderStoMaxListReq = new QueryTargetCycleCodeOrderStoMaxListReq();
        queryTargetCycleCodeOrderStoMaxListReq.setIsParentCycle("TRUE");//sourceId:1804345_1_68501
        queryTargetCycleCodeOrderStoMaxListReq.setIsArchive("FALSE");//sourceId:1804347_1_68501
        if (reqDto != null) {
            queryTargetCycleCodeOrderStoMaxListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1804342_1_68501
            queryTargetCycleCodeOrderStoMaxListReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1804343_1_68501
            queryTargetCycleCodeOrderStoMaxListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1804346_1_68501
            queryTargetCycleCodeOrderStoMaxListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1804348_1_68501
        }

        /*3-3-09查目标周期（标识排序小到大）列表[7584]   */
        Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaObjEntityId(), "D3执行刷全模板目标内容树排序-3-3-09查目标周期（标识排序小到大）列表-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaObjTypeCode(), "D3执行刷全模板目标内容树排序-3-3-09查目标周期（标识排序小到大）列表-被评对象类型编码不能为空", false);
        Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getIsParentCycle(), "D3执行刷全模板目标内容树排序-3-3-09查目标周期（标识排序小到大）列表-是否父周期不能为空", false);
        Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaluationTemplateId(), "D3执行刷全模板目标内容树排序-3-3-09查目标周期（标识排序小到大）列表-冗余评价模板ID不能为空", false);
        Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getIsArchive(), "D3执行刷全模板目标内容树排序-3-3-09查目标周期（标识排序小到大）列表-是否存档不能为空", false);
        Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getSpaceId(), "D3执行刷全模板目标内容树排序-3-3-09查目标周期（标识排序小到大）列表-创建于空间ID不能为空", false);
        listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryTargetCycleCodeOrderStoMaxList(queryTargetCycleCodeOrderStoMaxListReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((listOmsEvaluationObjectTargetCycle != null && listOmsEvaluationObjectTargetCycle != null && listOmsEvaluationObjectTargetCycle.size() > 0)) {
            //if(3-3-09查目标周期（标识排序小到大）列表.被评对象目标周期列表数据集条数 大于 0)  68503

//ModelCode: circulationCollections
            for (OmsEvaluationObjectTargetCycle circulationCollectionsRes : listOmsEvaluationObjectTargetCycle) {

                if ((circulationCollectionsRes != null && circulationCollectionsRes.getTargetCycleContentTypeCode() != null && circulationCollectionsRes.getTargetCycleContentTypeCode().equals("TARGET"))) {
                    //if(M3目标周期发牌【循环开始】.关联目标内容类型编码 等于 目标)  68507

                    ImplementWriteBackTargetCycleTreeOrderNumberComRespDto implementWriteBackTargetCycleTreeOrderNumberComRespDto = null;
                    ImplementWriteBackTargetCycleTreeOrderNumberComReqDto implementWriteBackTargetCycleTreeOrderNumberComReqDto = new ImplementWriteBackTargetCycleTreeOrderNumberComReqDto();
                    implementWriteBackTargetCycleTreeOrderNumberComReqDto.setTargetTreeOrderNumber("101");//CUSTOM_CONVENTION//sourceId:1805371_1_68512
                    if (circulationCollectionsRes != null) {
                        implementWriteBackTargetCycleTreeOrderNumberComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1805370_1_68512
                    }
                    if (reqDto != null) {
                        implementWriteBackTargetCycleTreeOrderNumberComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1805372_1_68512
                        implementWriteBackTargetCycleTreeOrderNumberComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1805373_1_68512
                    }

                    /*D3执行回写目标周期树排序(公共)[9594]   */
                    Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getTargetTreeOrderNumber(), "D3执行刷全模板目标内容树排序-D3执行回写目标周期树排序(公共)-目标树排序不能为空", false);
                    Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getTargetCycleContentId(), "D3执行刷全模板目标内容树排序-D3执行回写目标周期树排序(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getEvaluationTemplateId(), "D3执行刷全模板目标内容树排序-D3执行回写目标周期树排序(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getSpaceId(), "D3执行刷全模板目标内容树排序-D3执行回写目标周期树排序(公共)-创建于空间ID不能为空", false);
                    implementWriteBackTargetCycleTreeOrderNumberComRespDto = implementWriteBackTargetCycleTreeOrderNumberCom(implementWriteBackTargetCycleTreeOrderNumberComReqDto)/*vcase invoke 同服务,同domain*/;


                } else {
                    //else  68508

                    ImplementLoopWriteBackTargetCycleTreeOrderNumberComRespDto implementLoopWriteBackTargetCycleTreeOrderNumberComRespDto = null;
                    ImplementLoopWriteBackTargetCycleTreeOrderNumberComReqDto implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto = new ImplementLoopWriteBackTargetCycleTreeOrderNumberComReqDto();
                    if (reqDto != null) {
                        implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1805639_1_68514
                        implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1805640_1_68514
                        implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1805642_1_68514
                        implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1805643_1_68514
                    }
                    if (circulationCollectionsRes != null) {
                        implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.setParentEvaObjTargetCycleId(circulationCollectionsRes.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1805641_1_68514
                    }

                    /*D3执行循环回写目标周期树排序(公共)[9595]   */
                    Assert.isNull(implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.getEvaObjEntityId(), "D3执行刷全模板目标内容树排序-D3执行循环回写目标周期树排序(公共)-被评对象内容表主键ID不能为空", false);
                    Assert.isNull(implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.getEvaObjTypeCode(), "D3执行刷全模板目标内容树排序-D3执行循环回写目标周期树排序(公共)-被评对象类型编码不能为空", false);
                    Assert.isNull(implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.getParentEvaObjTargetCycleId(), "D3执行刷全模板目标内容树排序-D3执行循环回写目标周期树排序(公共)-上级被评对象目标周期标识不能为空", false);
                    Assert.isNull(implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.getEvaluationTemplateId(), "D3执行刷全模板目标内容树排序-D3执行循环回写目标周期树排序(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto.getSpaceId(), "D3执行刷全模板目标内容树排序-D3执行循环回写目标周期树排序(公共)-创建于空间ID不能为空", false);
                    implementLoopWriteBackTargetCycleTreeOrderNumberComRespDto = implementLoopWriteBackTargetCycleTreeOrderNumberCom(implementLoopWriteBackTargetCycleTreeOrderNumberComReqDto)/*vcase invoke 同服务,同domain*/;


                }
//ModelCode: circulationEnd
            }

        }
        ImplementBrushTempTargetContTreeOrderNumRespDto retData = new ImplementBrushTempTargetContTreeOrderNumRespDto();


        return retData;
    }

    /**
     * D3执行回写目标周期树排序(公共)[9594]
     * gen by moon at 5/18/2024, 12:01:38 AM
     */
    @Trace(operationName = "D3执行回写目标周期树排序(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementWriteBackTargetCycleTreeOrderNumberComRespDto implementWriteBackTargetCycleTreeOrderNumberCom(ImplementWriteBackTargetCycleTreeOrderNumberComReqDto reqDto) {


        //步骤0: M3执行第四接收字段（特殊方法） - implementFourthReceivingField
        //ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes = null;
        ImplementFourthReceivingFieldReqDto receptionServiceReq = new ImplementFourthReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1805331_1
            receptionServiceReq.setTargetTreeOrderNumber(reqDto.getTargetTreeOrderNumber());//SimpleFieldAssign//sourceId:1805337_1
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1805335_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1805353_1
        }

        /*M3接收入参字段[8259]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getTargetCycleContentId(), "D3执行回写目标周期树排序(公共)-M3接收入参字段-关联目标内容ID不能为空", false);
        Assert.isNull(receptionServiceReq.getTargetTreeOrderNumber(), "D3执行回写目标周期树排序(公共)-M3接收入参字段-目标树排序不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D3执行回写目标周期树排序(公共)-M3接收入参字段-冗余评价模板ID不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D3执行回写目标周期树排序(公共)-M3接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbTargetContCom.implementFourthReceivingField(receptionServiceReq);


//步骤1: 3-3-09查目标周期（标识排序小到大）列表 - queryTargetCycleCodeOrderStoMaxList
        List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle = new ArrayList<>();
        QueryTargetCycleCodeOrderStoMaxListReq queryTargetCycleCodeOrderStoMaxListReq = new QueryTargetCycleCodeOrderStoMaxListReq();
        queryTargetCycleCodeOrderStoMaxListReq.setIsArchive("FALSE");//sourceId:1805351_1
        if (reqDto != null) {
            queryTargetCycleCodeOrderStoMaxListReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1805345_1
            queryTargetCycleCodeOrderStoMaxListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1805347_1
            queryTargetCycleCodeOrderStoMaxListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1805349_1
        }

        /*3-3-09查目标周期（标识排序小到大）列表[7584]   */
        Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getTargetCycleContentId(), "D3执行回写目标周期树排序(公共)-3-3-09查目标周期（标识排序小到大）列表-关联目标内容ID不能为空", false);
        Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaluationTemplateId(), "D3执行回写目标周期树排序(公共)-3-3-09查目标周期（标识排序小到大）列表-冗余评价模板ID不能为空", false);
        Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getIsArchive(), "D3执行回写目标周期树排序(公共)-3-3-09查目标周期（标识排序小到大）列表-是否存档不能为空", false);
        Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getSpaceId(), "D3执行回写目标周期树排序(公共)-3-3-09查目标周期（标识排序小到大）列表-创建于空间ID不能为空", false);
        listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryTargetCycleCodeOrderStoMaxList(queryTargetCycleCodeOrderStoMaxListReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤2: 3-3-09-01批量改被评对象目标周期 - batchUpdateEvaObjTargetCycle
        boolean bOOLEAN;
        if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle.size() > 0) {
            List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_2 = new ArrayList<>();
            if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)) {
                listOmsEvaluationObjectTargetCycle_2 = //objList-to-objLists
                        listOmsEvaluationObjectTargetCycle.stream().map(item -> {
                            OmsEvaluationObjectTargetCycle elm = new OmsEvaluationObjectTargetCycle();
                            elm.setEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:363443_2
                            elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:363444_2
                            elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:363445_2
                            if (reqDto != null) {
                                elm.setTargetTreeOrderNumber(reqDto.getTargetTreeOrderNumber());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:363447_2
                            }
                            return elm;
                        }).collect(Collectors.toList());//objList-to-objLists//sourceId:1805365_1
            }

            /*3-3-09-01批量改被评对象目标周期[2664]   */

            bOOLEAN = mOmsEvaluationObjectTargetCycleService.batchUpdateEvaObjTargetCycle(listOmsEvaluationObjectTargetCycle_2)/*vcase invoke 本地 method 方法调用;*/;


        }

        ImplementWriteBackTargetCycleTreeOrderNumberComRespDto retData = new ImplementWriteBackTargetCycleTreeOrderNumberComRespDto();


        return retData;
    }

    /**
     * D3执行循环回写目标周期树排序(公共)[9595]
     * gen by moon at 5/17/2024, 2:19:38 AM
     */
    @Trace(operationName = "D3执行循环回写目标周期树排序(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementLoopWriteBackTargetCycleTreeOrderNumberComRespDto implementLoopWriteBackTargetCycleTreeOrderNumberCom(ImplementLoopWriteBackTargetCycleTreeOrderNumberComReqDto reqDto) {


        //virtualUsage 3-3-09查询目标周期（内容排序从小到大）列表  68520
        List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle = new ArrayList<>();
        QueryTargetCycleByOrderNumFormSmallToLagListReq queryTargetCycleByOrderNumFormSmallToLagListReq = new QueryTargetCycleByOrderNumFormSmallToLagListReq();
        queryTargetCycleByOrderNumFormSmallToLagListReq.setIsParentCycle("TRUE");//sourceId:1805422_1_68520
        queryTargetCycleByOrderNumFormSmallToLagListReq.setIsArchive("FALSE");//sourceId:1805424_1_68520
        if (reqDto != null) {
            queryTargetCycleByOrderNumFormSmallToLagListReq.setParentEvaObjTargetCycleId(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1805419_1_68520
            queryTargetCycleByOrderNumFormSmallToLagListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1805420_1_68520
            queryTargetCycleByOrderNumFormSmallToLagListReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1805421_1_68520
            queryTargetCycleByOrderNumFormSmallToLagListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1805423_1_68520
            queryTargetCycleByOrderNumFormSmallToLagListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1805425_1_68520
        }

        /*3-3-09查询目标周期（内容排序从小到大）列表[9593]   */
        Assert.isNull(queryTargetCycleByOrderNumFormSmallToLagListReq.getParentEvaObjTargetCycleId(), "D3执行循环回写目标周期树排序(公共)-3-3-09查询目标周期（内容排序从小到大）列表-上级被评对象目标周期标识不能为空", false);
        Assert.isNull(queryTargetCycleByOrderNumFormSmallToLagListReq.getEvaObjEntityId(), "D3执行循环回写目标周期树排序(公共)-3-3-09查询目标周期（内容排序从小到大）列表-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryTargetCycleByOrderNumFormSmallToLagListReq.getEvaObjTypeCode(), "D3执行循环回写目标周期树排序(公共)-3-3-09查询目标周期（内容排序从小到大）列表-被评对象类型编码不能为空", false);
        Assert.isNull(queryTargetCycleByOrderNumFormSmallToLagListReq.getIsParentCycle(), "D3执行循环回写目标周期树排序(公共)-3-3-09查询目标周期（内容排序从小到大）列表-是否父周期不能为空", false);
        Assert.isNull(queryTargetCycleByOrderNumFormSmallToLagListReq.getEvaluationTemplateId(), "D3执行循环回写目标周期树排序(公共)-3-3-09查询目标周期（内容排序从小到大）列表-冗余评价模板ID不能为空", false);
        Assert.isNull(queryTargetCycleByOrderNumFormSmallToLagListReq.getIsArchive(), "D3执行循环回写目标周期树排序(公共)-3-3-09查询目标周期（内容排序从小到大）列表-是否存档不能为空", false);
        Assert.isNull(queryTargetCycleByOrderNumFormSmallToLagListReq.getSpaceId(), "D3执行循环回写目标周期树排序(公共)-3-3-09查询目标周期（内容排序从小到大）列表-创建于空间ID不能为空", false);
        listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryTargetCycleByOrderNumFormSmallToLagList(queryTargetCycleByOrderNumFormSmallToLagListReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((listOmsEvaluationObjectTargetCycle != null && listOmsEvaluationObjectTargetCycle != null && listOmsEvaluationObjectTargetCycle.size() > 0)) {
            //if(3-3-09查询目标周期（内容排序从小到大）列表.被评对象目标周期列表数据集条数 大于 0)  68521

            QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
            QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto = new QueryEvaObjTargetCyclePlatformDetailComReqDto();
            queryEvaObjTargetCyclePlatformDetailComReqDto.setIsParentCycle("TRUE");//sourceId:1805584_1_68524
            queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1805585_1_68524
            if (reqDto != null) {
                queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleCode(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1805631_1_68524
                queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1805582_1_68524
                queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1805583_1_68524
                queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1805586_1_68524
                queryEvaObjTargetCyclePlatformDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1805587_1_68524
            }

            /*D3查上级目标内容目标树排序[8528]   */
            Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleCode(), "D3执行循环回写目标周期树排序(公共)-D3查上级目标内容目标树排序-被评对象目标周期标识不能为空", false);
            Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjEntityId(), "D3执行循环回写目标周期树排序(公共)-D3查上级目标内容目标树排序-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTypeCode(), "D3执行循环回写目标周期树排序(公共)-D3查上级目标内容目标树排序-被评对象类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsParentCycle(), "D3执行循环回写目标周期树排序(公共)-D3查上级目标内容目标树排序-是否父周期不能为空", false);
            Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(), "D3执行循环回写目标周期树排序(公共)-D3查上级目标内容目标树排序-是否存档不能为空", false);
            Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(), "D3执行循环回写目标周期树排序(公共)-D3查上级目标内容目标树排序-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getSpaceId(), "D3执行循环回写目标周期树排序(公共)-D3查上级目标内容目标树排序-创建于空间ID不能为空", false);
            queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;


//ModelCode: circulationCollections
            for (OmsEvaluationObjectTargetCycle circulationCollectionsRes : listOmsEvaluationObjectTargetCycle) {

                ObtainOutPutCurrentTreeOrderNumberComRespDto obtainOutPutCurrentTreeOrderNumberComRespDto = null;
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    ObtainOutPutCurrentTreeOrderNumberComReqDto obtainOutPutCurrentTreeOrderNumberComReqDto = new ObtainOutPutCurrentTreeOrderNumberComReqDto();
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                        obtainOutPutCurrentTreeOrderNumberComReqDto.setSuperiorsTreeOrderNumbeir(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetTreeOrderNumber());//SimpleFieldAssign//sourceId:1805622_1_68525
                    }
                    if (circulationCollectionsRes != null) {
                        obtainOutPutCurrentTreeOrderNumberComReqDto.setOrderNumber(circulationCollectionsRes.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1805623_1_68525
                    }

                    /*D2输出当前树排序值(公共)[9596] 通过上级树排序与当前排序，分析出当前树排序值。例如：上级树排序值1001，本级排序1，则本级树排序值为10011001  */
                    Assert.isNull(obtainOutPutCurrentTreeOrderNumberComReqDto.getSuperiorsTreeOrderNumbeir(), "D3执行循环回写目标周期树排序(公共)-D2输出当前树排序值(公共)-上级树排序不能为空", false);
                    Assert.isNull(obtainOutPutCurrentTreeOrderNumberComReqDto.getOrderNumber(), "D3执行循环回写目标周期树排序(公共)-D2输出当前树排序值(公共)-排序不能为空", false);
                    obtainOutPutCurrentTreeOrderNumberComRespDto = interfaceModeService.obtainOutPutCurrentTreeOrderNumberCom(obtainOutPutCurrentTreeOrderNumberComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementWriteBackTargetCycleTreeOrderNumberComRespDto implementWriteBackTargetCycleTreeOrderNumberComRespDto = null;
                if (obtainOutPutCurrentTreeOrderNumberComRespDto != null) {
                    ImplementWriteBackTargetCycleTreeOrderNumberComReqDto implementWriteBackTargetCycleTreeOrderNumberComReqDto = new ImplementWriteBackTargetCycleTreeOrderNumberComReqDto();
                    if (obtainOutPutCurrentTreeOrderNumberComRespDto != null) {
                        implementWriteBackTargetCycleTreeOrderNumberComReqDto.setTargetTreeOrderNumber(obtainOutPutCurrentTreeOrderNumberComRespDto.getTreeOrderNumbeir());//SimpleFieldAssign//sourceId:1805508_1_68526
                    }
                    if (circulationCollectionsRes != null) {
                        implementWriteBackTargetCycleTreeOrderNumberComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1805507_1_68526
                    }
                    if (reqDto != null) {
                        implementWriteBackTargetCycleTreeOrderNumberComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1805509_1_68526
                        implementWriteBackTargetCycleTreeOrderNumberComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1805510_1_68526
                    }

                    /*D3执行回写目标周期树排序(公共)[9594]   */
                    Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getTargetTreeOrderNumber(), "D3执行循环回写目标周期树排序(公共)-D3执行回写目标周期树排序(公共)-目标树排序不能为空", false);
                    Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getTargetCycleContentId(), "D3执行循环回写目标周期树排序(公共)-D3执行回写目标周期树排序(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getEvaluationTemplateId(), "D3执行循环回写目标周期树排序(公共)-D3执行回写目标周期树排序(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(implementWriteBackTargetCycleTreeOrderNumberComReqDto.getSpaceId(), "D3执行循环回写目标周期树排序(公共)-D3执行回写目标周期树排序(公共)-创建于空间ID不能为空", false);
                    implementWriteBackTargetCycleTreeOrderNumberComRespDto = implementWriteBackTargetCycleTreeOrderNumberCom(implementWriteBackTargetCycleTreeOrderNumberComReqDto)/*vcase invoke 同服务,同domain*/;


                }
//ModelCode: circulationEnd
            }

        }
        ImplementLoopWriteBackTargetCycleTreeOrderNumberComRespDto retData = new ImplementLoopWriteBackTargetCycleTreeOrderNumberComRespDto();


        return retData;
    }

    /**
     * D3查询目标内容属性公共信息(公共)[10084]
     * gen by moon at 8/8/2024, 10:03:48 PM
     */
    @Trace(operationName = "D3查询目标内容属性公共信息(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryTargetContNatureComInfoDetailComRespDto queryTargetContNatureComInfoDetailCom(QueryTargetContNatureComInfoDetailComReqDto reqDto) {


        ImplementAcceptFieldRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getTableTypeCode() != null && reqDto.getTableTypeCode().equals("OMS_TARGET_CATEGORY"))) {
            //if(D3查询目标内容属性公共信息(公共).内容表类型编码 等于 目标分类表)  72061

            OmsTargetCategory omsTargetCategory = null;
            QueryTargetCatDetailReq queryTargetCatDetailReq = new QueryTargetCatDetailReq();
            if (reqDto != null) {
                queryTargetCatDetailReq.setTargetCategoryId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1965026_1_72063
                queryTargetCatDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1965027_1_72063
            }

            /*3-3-02查目标分类详情[2595]   */
            Assert.isNull(queryTargetCatDetailReq.getTargetCategoryId(), "D3查询目标内容属性公共信息(公共)-3-3-02查目标分类详情-目标分类ID不能为空", false);
            Assert.isNull(queryTargetCatDetailReq.getEvaluationTemplateId(), "D3查询目标内容属性公共信息(公共)-3-3-02查目标分类详情-冗余评价模板ID不能为空", false);
            omsTargetCategory = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes = null;
            if (omsTargetCategory != null) {
                ImplementAcceptFieldReqDto receptionServiceReq = new ImplementAcceptFieldReqDto();
                if (omsTargetCategory != null) {
                    receptionServiceReq.setIsLast(omsTargetCategory.getIsLast());//SimpleFieldAssign//sourceId:1965046_1_72065
                    receptionServiceReq.setLevelNumber(omsTargetCategory.getLevelNumber());//SimpleFieldAssign//sourceId:1965047_1_72065
                }

                /*M3接收内容属性信息出参[6100]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getIsLast(), "D3查询目标内容属性公共信息(公共)-M3接收内容属性信息出参-是否末级不能为空", false);
                Assert.isNull(receptionServiceReq.getLevelNumber(), "D3查询目标内容属性公共信息(公共)-M3接收内容属性信息出参-层级不能为空", false);
                receptionServiceRes = nbTargetContCom.implementAcceptField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((reqDto != null && reqDto.getTableTypeCode() != null && reqDto.getTableTypeCode().equals("OMS_TARGET_OBJECTIVE"))) {
            //elseif(D3查询目标内容属性公共信息(公共).内容表类型编码 等于 指标表)  72062

            OmsTargetObjective omsTargetObjective = null;
            QueryTargetObjDetailReq queryTargetObjDetailReq = new QueryTargetObjDetailReq();
            if (reqDto != null) {
                queryTargetObjDetailReq.setObjectiveId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1965033_1_72064
                queryTargetObjDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1965034_1_72064
            }

            /*3-3-03查指标详情[2697]   */
            Assert.isNull(queryTargetObjDetailReq.getObjectiveId(), "D3查询目标内容属性公共信息(公共)-3-3-03查指标详情-指标ID不能为空", false);
            Assert.isNull(queryTargetObjDetailReq.getEvaluationTemplateId(), "D3查询目标内容属性公共信息(公共)-3-3-03查指标详情-冗余评价模板ID不能为空", false);
            omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
            if (omsTargetObjective != null) {
                ImplementAcceptFieldReqDto receptionServiceReq_1 = new ImplementAcceptFieldReqDto();
                if (omsTargetObjective != null) {
                    receptionServiceReq_1.setIsLast(omsTargetObjective.getIsLastObjective());//SimpleFieldAssign//sourceId:1965046_1_72066
                    receptionServiceReq_1.setLevelNumber(omsTargetObjective.getLevelNumber());//SimpleFieldAssign//sourceId:1965047_1_72066
                }

                /*M3接收内容属性信息出参[6100]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getIsLast(), "D3查询目标内容属性公共信息(公共)-M3接收内容属性信息出参-是否末级不能为空", false);
                Assert.isNull(receptionServiceReq_1.getLevelNumber(), "D3查询目标内容属性公共信息(公共)-M3接收内容属性信息出参-层级不能为空", false);
                receptionServiceRes_2 = nbTargetContCom.implementAcceptField(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        }
        QueryTargetContNatureComInfoDetailComRespDto retData = new QueryTargetContNatureComInfoDetailComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setIsLast(receptionServiceRes_1.getIsLast());//SimpleFieldAssign//sourceId:1965052_1
            retData.setLevelNumber(receptionServiceRes_1.getLevelNumber());//SimpleFieldAssign//sourceId:1965053_1
        }


        return retData;
    }

    /**
     * D3查询目标内容面包屑列表[10088]
     * gen by moon at 8/9/2024, 3:54:56 PM
     */
    @Trace(operationName = "D3查询目标内容面包屑列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryTargetContCrumbsListRespDto queryTargetContCrumbsList(QueryTargetContCrumbsListReqDto reqDto) {


        QueryAncestorTargetCycleListComRespDto queryAncestorTargetCycleListComRespDto_1 = null;
//步骤0: M3接收外部字段(特殊方法） - obtainReceiveOutField
        //ModelCode: receptionService
        ObtainReceiveOutFieldRespDto receptionServiceRes = null;
        ObtainReceiveOutFieldReqDto receptionServiceReq = new ObtainReceiveOutFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1966730_1
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1966726_1
        }

        /*M3接收入参字段[4608]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(), "D3查询目标内容面包屑列表-M3接收入参字段-被评对象目标周期ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D3查询目标内容面包屑列表-M3接收入参字段-冗余评价模板ID不能为空", false);
        receptionServiceRes = nbTargetContCom.obtainReceiveOutField(receptionServiceReq);


//步骤1: D3-查询被评对象目标周期平台详情(公共) - queryEvaObjTargetCyclePlatformDetailCom
        QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
        QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto = new QueryEvaObjTargetCyclePlatformDetailComReqDto();
        if (reqDto != null) {
            queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1966801_1
            queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1966802_1
        }

        /*D3-查询被评对象目标周期平台详情(公共)[8528]   */
        Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(), "D3查询目标内容面包屑列表-D3-查询被评对象目标周期平台详情(公共)-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(), "D3查询目标内容面包屑列表-D3-查询被评对象目标周期平台详情(公共)-冗余评价模板ID不能为空", false);
        queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;


//步骤2: D3查祖先目标周期列表(公共) - queryAncestorTargetCycleListCom
        QueryAncestorTargetCycleListComRespDto queryAncestorTargetCycleListComRespDto = null;
        if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
            QueryAncestorTargetCycleListComReqDto queryAncestorTargetCycleListComReqDto = new QueryAncestorTargetCycleListComReqDto();
            if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                queryAncestorTargetCycleListComReqDto.setComCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1966373_1
                queryAncestorTargetCycleListComReqDto.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1966374_1
                queryAncestorTargetCycleListComReqDto.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1966375_1
            }
            if (reqDto != null) {
                queryAncestorTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1966376_1
            }

            /*D3查祖先目标周期列表(公共)[6312]   */
            Assert.isNull(queryAncestorTargetCycleListComReqDto.getComCode(), "D3查询目标内容面包屑列表-D3查祖先目标周期列表(公共)-通用编码标识不能为空", false);
            Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaObjEntityId(), "D3查询目标内容面包屑列表-D3查祖先目标周期列表(公共)-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaObjTypeCode(), "D3查询目标内容面包屑列表-D3查祖先目标周期列表(公共)-被评对象类型编码不能为空", false);
            Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaluationTemplateId(), "D3查询目标内容面包屑列表-D3查祖先目标周期列表(公共)-冗余评价模板ID不能为空", false);
            queryAncestorTargetCycleListComRespDto = targetContentService.queryAncestorTargetCycleListCom(queryAncestorTargetCycleListComReqDto)/*vcase invoke isSameApp*/;


            queryAncestorTargetCycleListComRespDto_1 = queryAncestorTargetCycleListComRespDto;
        }

        QueryTargetContCrumbsListRespDto retData = new QueryTargetContCrumbsListRespDto();
        if (queryAncestorTargetCycleListComRespDto_1 != null) {
            retData.setEvaObjTargetCycleList(queryAncestorTargetCycleListComRespDto_1.getEvaObjTargetCycleList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1966803_1
        }


        return retData;
    }

    /**
     * D3批量查目标周期By内容ID（时间范围切）(公共)[10245]
     * gen by moon at 9/29/2024, 10:05:08 PM
     */
    @Trace(operationName = "D3批量查目标周期By内容ID（时间范围切）(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementBatchQueryByContIdTimeSectionComRespDto implementBatchQueryByContIdTimeSectionCom(ImplementBatchQueryByContIdTimeSectionComReqDto reqDto) {


        List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_1 = new ArrayList<>();
//步骤0: 3-3-09执行批量查目标周期By内容ID（时间范围切） - implementBatchQueryByContIdTimeSection
        List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle = new ArrayList<>();
        ImplementBatchQueryByContIdTimeSectionReq implementBatchQueryByContIdTimeSectionReq = new ImplementBatchQueryByContIdTimeSectionReq();
        if (reqDto != null) {
            implementBatchQueryByContIdTimeSectionReq.setEvaObjTargetCycleList(reqDto.getEvaObjTargetCycleList());//list-field-assign//sourceId:2011077_1
            implementBatchQueryByContIdTimeSectionReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2011078_1
            implementBatchQueryByContIdTimeSectionReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2012118_1
            implementBatchQueryByContIdTimeSectionReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2011093_1
            implementBatchQueryByContIdTimeSectionReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:2011094_1
            implementBatchQueryByContIdTimeSectionReq.setIsParentCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:2011079_1
            implementBatchQueryByContIdTimeSectionReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2011080_1
            implementBatchQueryByContIdTimeSectionReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2011081_1
            implementBatchQueryByContIdTimeSectionReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2011082_1
        }

        /*3-3-09执行批量查目标周期By内容ID（时间范围切）[10244]   */

        listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.implementBatchQueryByContIdTimeSection(implementBatchQueryByContIdTimeSectionReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsEvaluationObjectTargetCycle_1 = listOmsEvaluationObjectTargetCycle;

        ImplementBatchQueryByContIdTimeSectionComRespDto retData = new ImplementBatchQueryByContIdTimeSectionComRespDto();
        retData.setEvaObjTargetCycleList(listOmsEvaluationObjectTargetCycle_1.stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2011090_1


        return retData;
    }

    /**
     * D3查询规划数据导出内容范围列表(公共)[10479]
     * gen by moon at 5/8/2025, 9:27:40 PM
     */
    @Trace(operationName = "D3查询规划数据导出内容范围列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryPlanningDataExportRangeListComRespDto queryPlanningDataExportRangeListCom(QueryPlanningDataExportRangeListComReqDto reqDto) {


        ImplementParentSubMidCycleTypeTurnSingleFieldComRespDto implementParentSubMidCycleTypeTurnSingleFieldComRespDto_1 = null;
        QueryConOfEvaTempleteListComRespDto queryConOfEvaTempleteListComRespDto_1 = null;
        List<OmsEvaluationTemplate> listOmsEvaluationTemplate_1 = new ArrayList<>();
        List<OmsTargetCategory> listOmsTargetCategory_1 = new ArrayList<>();
        List<OmsTargetCategory> listOmsTargetCategory_3 = new ArrayList<>();
        BatchQueryVirtualCircleByContComRespDto batchQueryVirtualCircleByContComRespDto_1 = null;
//virtualUsage D3执行父子中周期类型转单字段(公共)  74028
        ImplementParentSubMidCycleTypeTurnSingleFieldComRespDto implementParentSubMidCycleTypeTurnSingleFieldComRespDto = null;
        ImplementParentSubMidCycleTypeTurnSingleFieldComReqDto implementParentSubMidCycleTypeTurnSingleFieldComReqDto = new ImplementParentSubMidCycleTypeTurnSingleFieldComReqDto();
        if (reqDto != null) {
            implementParentSubMidCycleTypeTurnSingleFieldComReqDto.setPeriodId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2038958_1_74028
            implementParentSubMidCycleTypeTurnSingleFieldComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2038956_1_74028
        }

        /*D3执行父子中周期类型转单字段(公共)[9364]   */
        Assert.isNull(implementParentSubMidCycleTypeTurnSingleFieldComReqDto.getParentSubMidCycleType(), "D3查询规划数据导出内容范围列表(公共)-D3执行父子中周期类型转单字段(公共)-父子中周期类型不能为空", false);
        implementParentSubMidCycleTypeTurnSingleFieldComRespDto = targetCalcService.implementParentSubMidCycleTypeTurnSingleFieldCom(implementParentSubMidCycleTypeTurnSingleFieldComReqDto)/*vcase invoke isSameApp*/;


        implementParentSubMidCycleTypeTurnSingleFieldComRespDto_1 = implementParentSubMidCycleTypeTurnSingleFieldComRespDto;
//virtualUsage D3查询评价模板下内容列表(公共)  74027
        QueryConOfEvaTempleteListComRespDto queryConOfEvaTempleteListComRespDto = null;
        if (implementParentSubMidCycleTypeTurnSingleFieldComRespDto != null) {
            QueryConOfEvaTempleteListComReqDto queryConOfEvaTempleteListComReqDto = new QueryConOfEvaTempleteListComReqDto();
            if (implementParentSubMidCycleTypeTurnSingleFieldComRespDto != null) {
                queryConOfEvaTempleteListComReqDto.setCycleId(implementParentSubMidCycleTypeTurnSingleFieldComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:2047073_1_74027
                queryConOfEvaTempleteListComReqDto.setIsParentCycle(implementParentSubMidCycleTypeTurnSingleFieldComRespDto.getIsParentCycle());//SimpleFieldAssign//sourceId:2047074_1_74027
                queryConOfEvaTempleteListComReqDto.setIsMetaphase(implementParentSubMidCycleTypeTurnSingleFieldComRespDto.getIsMetaphase());//SimpleFieldAssign//sourceId:2047075_1_74027
                queryConOfEvaTempleteListComReqDto.setIsSubCycle(implementParentSubMidCycleTypeTurnSingleFieldComRespDto.getIsSubCycle());//SimpleFieldAssign//sourceId:2047076_1_74027
            }
            if (reqDto != null) {
                queryConOfEvaTempleteListComReqDto.setLevelNumber(reqDto.getLevelNumber());//SimpleFieldAssign//sourceId:2047077_1_74027
                queryConOfEvaTempleteListComReqDto.setIsLastObjective(reqDto.getIsLastObjective());//SimpleFieldAssign//sourceId:2047078_1_74027
                queryConOfEvaTempleteListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2047079_1_74027
                queryConOfEvaTempleteListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2047080_1_74027
            }

            /*D3查询评价模板下内容列表(公共)[10526]   */
            Assert.isNull(queryConOfEvaTempleteListComReqDto.getEvaluationTemplateId(), "D3查询规划数据导出内容范围列表(公共)-D3查询评价模板下内容列表(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(queryConOfEvaTempleteListComReqDto.getSpaceId(), "D3查询规划数据导出内容范围列表(公共)-D3查询评价模板下内容列表(公共)-创建于空间ID不能为空", false);
            queryConOfEvaTempleteListComRespDto = dashboardTargetContentService.queryConOfEvaTempleteListCom(queryConOfEvaTempleteListComReqDto)/*vcase invoke isSameApp*/;


            queryConOfEvaTempleteListComRespDto_1 = queryConOfEvaTempleteListComRespDto;
        }
        if ((queryConOfEvaTempleteListComRespDto != null && queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList() != null && queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList().size() > 0)) {
            //if(D3查询评价模板下内容列表(公共).被评对象目标周期列表数据集条数 大于 0)  73836

            List<OmsEvaluationTemplate> listOmsEvaluationTemplate = new ArrayList<>();
            if (queryConOfEvaTempleteListComRespDto != null) {
                BatchQueryEvaTempReq batchQueryEvaTempReq = new BatchQueryEvaTempReq();
                batchQueryEvaTempReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2038438_1_73839
                if (queryConOfEvaTempleteListComRespDto != null && queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList() != null && !CollectionUtil.isEmpty(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList())) {
                    batchQueryEvaTempReq.setEvalTempList(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList().stream().map(item -> item.getEvaluationTemplateId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038435_1_73839
                }

                /*3-2-02批量查询评价模板[3075]   */
                Assert.isNull(batchQueryEvaTempReq.getSubjectLifeCycle(), "D3查询规划数据导出内容范围列表(公共)-3-2-02批量查询评价模板-主体生命周期不能为空", false);
                listOmsEvaluationTemplate = mOmsEvaluationTemplateService.batchQueryEvaTemp(batchQueryEvaTempReq)/*vcase invoke 本地 method 方法调用;*/;


                listOmsEvaluationTemplate_1 = listOmsEvaluationTemplate;
            }
            List<OmsTargetCategory> listOmsTargetCategory = new ArrayList<>();
            if (queryConOfEvaTempleteListComRespDto != null) {
                BatchQueryTargetCatReq batchQueryTargetCatReq = new BatchQueryTargetCatReq();
                batchQueryTargetCatReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2038420_1_73837
                if (queryConOfEvaTempleteListComRespDto != null && queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList() != null && !CollectionUtil.isEmpty(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList())) {
                    batchQueryTargetCatReq.setSetConstructionTaskList(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList().stream().map(item -> item.getCorrelationLastTargetCatId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038419_1_73837
                }
                if (reqDto != null) {
                    batchQueryTargetCatReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2038426_1_73837
                }

                /*3-3-02批量查目标分类列表（查末级目标分类）[2254]   */
                Assert.isNull(batchQueryTargetCatReq.getEvaluationTemplateId(), "D3查询规划数据导出内容范围列表(公共)-3-3-02批量查目标分类列表（查末级目标分类）-冗余评价模板ID不能为空", false);
                Assert.isNull(batchQueryTargetCatReq.getSubjectLifeCycle(), "D3查询规划数据导出内容范围列表(公共)-3-3-02批量查目标分类列表（查末级目标分类）-主体生命周期不能为空", false);
                listOmsTargetCategory = mOmsTargetCategoryService.batchQueryTargetCat(batchQueryTargetCatReq)/*vcase invoke 本地 method 方法调用;*/;


                listOmsTargetCategory_1 = listOmsTargetCategory;
            }
            List<OmsTargetCategory> listOmsTargetCategory_2 = new ArrayList<>();
            if (queryConOfEvaTempleteListComRespDto != null) {
                BatchQueryTargetCatReq batchQueryTargetCatReq_1 = new BatchQueryTargetCatReq();
                batchQueryTargetCatReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2038428_1_73838
                if (queryConOfEvaTempleteListComRespDto != null && queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList() != null && !CollectionUtil.isEmpty(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList())) {
                    batchQueryTargetCatReq_1.setSetConstructionTaskList(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList().stream().map(item -> item.getRootTargetCategoryId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038427_1_73838
                }
                if (reqDto != null) {
                    batchQueryTargetCatReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2038434_1_73838
                }

                /*3-3-02批量查目标分类列表（查一级目标分类）[2254]   */
                Assert.isNull(batchQueryTargetCatReq_1.getEvaluationTemplateId(), "D3查询规划数据导出内容范围列表(公共)-3-3-02批量查目标分类列表（查一级目标分类）-冗余评价模板ID不能为空", false);
                Assert.isNull(batchQueryTargetCatReq_1.getSubjectLifeCycle(), "D3查询规划数据导出内容范围列表(公共)-3-3-02批量查目标分类列表（查一级目标分类）-主体生命周期不能为空", false);
                listOmsTargetCategory_2 = mOmsTargetCategoryService.batchQueryTargetCat(batchQueryTargetCatReq_1)/*vcase invoke 本地 method 方法调用;*/;


                listOmsTargetCategory_3 = listOmsTargetCategory_2;
            }
            BatchQueryVirtualCircleByContComRespDto batchQueryVirtualCircleByContComRespDto = null;
            if (queryConOfEvaTempleteListComRespDto != null) {
                BatchQueryVirtualCircleByContComReqDto batchQueryVirtualCircleByContComReqDto = new BatchQueryVirtualCircleByContComReqDto();
                if (queryConOfEvaTempleteListComRespDto != null && queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList() != null && !CollectionUtil.isEmpty(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList())) {
                    batchQueryVirtualCircleByContComReqDto.setTargetContentList(queryConOfEvaTempleteListComRespDto.getEvaObjTargetCycleList().stream().map(item -> item.getTargetCycleContentId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038448_1_73843
                }

                /*D3批量查询虚拟圈子By内容(公共)[10142]   */

                batchQueryVirtualCircleByContComRespDto = virtualOrgService.batchQueryVirtualCircleByContCom(batchQueryVirtualCircleByContComReqDto)/*vcase invoke isSameApp*/;


                batchQueryVirtualCircleByContComRespDto_1 = batchQueryVirtualCircleByContComRespDto;
            }
        }
        QueryPlanningDataExportRangeListComRespDto retData = new QueryPlanningDataExportRangeListComRespDto();
        //数据集融合  MoreListToOneSource
        if (queryConOfEvaTempleteListComRespDto_1 != null && !CollectionUtil.isEmpty(queryConOfEvaTempleteListComRespDto_1.getEvaObjTargetCycleList())) {
            for (EvaObjTargetCycleDto evaObjTargetCycleDto : queryConOfEvaTempleteListComRespDto_1.getEvaObjTargetCycleList()) {
                PlanningExportDetailDto retElm = new PlanningExportDetailDto();
                if (queryConOfEvaTempleteListComRespDto_1 != null) {
                    retElm.setTargetCycleContentId(evaObjTargetCycleDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:434474_2
                    retElm.setEvaObjTargetCycleId(evaObjTargetCycleDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:434477_2
                    retElm.setObjectiveShortName(evaObjTargetCycleDto.getObjectiveShortName());//SimpleFieldAssign//sourceId:434475_2
                }
                retData.getPlanningExportDetailList().add(retElm);
                if (listOmsEvaluationTemplate_1 != null && !CollectionUtil.isEmpty(listOmsEvaluationTemplate_1)) {
                    for (OmsEvaluationTemplate omsEvaluationTemplate : listOmsEvaluationTemplate_1) {
                        if (omsEvaluationTemplate.getEvaluationTemplateId().equals(evaObjTargetCycleDto.getEvaluationTemplateId())) {
                            retElm.setEvaluationTempName(omsEvaluationTemplate.getEvaluationTempName());//SimpleFieldAssign//sourceId:431107_2
                        }
                    }
                }

                if (listOmsTargetCategory_3 != null && !CollectionUtil.isEmpty(listOmsTargetCategory_3)) {
                    for (OmsTargetCategory omsTargetCategory : listOmsTargetCategory_3) {
                        if (omsTargetCategory.getTargetCategoryId().equals(evaObjTargetCycleDto.getRootTargetCategoryId())) {
                            retElm.setRootTargetCategoryName(omsTargetCategory.getTargetCategoryName());//SimpleFieldAssign//sourceId:431106_2
                        }
                    }
                }

                if (listOmsTargetCategory_1 != null && !CollectionUtil.isEmpty(listOmsTargetCategory_1)) {
                    for (OmsTargetCategory omsTargetCategory : listOmsTargetCategory_1) {
                        if (omsTargetCategory.getTargetCategoryId().equals(evaObjTargetCycleDto.getCorrelationLastTargetCatId())) {
                            retElm.setLastTargetCategoryName(omsTargetCategory.getTargetCategoryName());//SimpleFieldAssign//sourceId:431105_2
                        }
                    }
                }

                if (batchQueryVirtualCircleByContComRespDto_1 != null) {
                    for (TargetContentDto targetContentDto : batchQueryVirtualCircleByContComRespDto_1.getTargetContentList()) {
                        if (targetContentDto.getEntityId().equals(evaObjTargetCycleDto.getTargetCycleContentId())) {
                            if (batchQueryVirtualCircleByContComRespDto_1 != null) {
                                retElm.setDeptId(targetContentDto.getDeptId());//SimpleFieldAssign//sourceId:431108_2
                                retElm.setPersonLiableInductionRecordId(targetContentDto.getPersonLiableInductionRecordId());//SimpleFieldAssign//sourceId:431109_2
                                retElm.setDirectorInductionRecordId(targetContentDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:431110_2
                            }
                        }
                    }
                }

            }
        }//sourceId:2038450_1
        if (implementParentSubMidCycleTypeTurnSingleFieldComRespDto_1 != null) {
            retData.setPeriodId(implementParentSubMidCycleTypeTurnSingleFieldComRespDto_1.getPeriodId());//SimpleFieldAssign//sourceId:2038994_1
        }


        return retData;
    }

    /**
     * D3查询规划数据导出内容明细列表(公共)[10480]
     * gen by moon at 1/1/2025, 6:30:11 PM
     */
    @Trace(operationName = "D3查询规划数据导出内容明细列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryPlanningDataExportDetailListComRespDto queryPlanningDataExportDetailListCom(QueryPlanningDataExportDetailListComReqDto reqDto) {


        QueryPlanningDataExportRangeListComRespDto queryPlanningDataExportRangeListComRespDto_1 = null;
        BatchQueryDeptComRespDto batchQueryDeptComRespDto_1 = null;
        BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto_1 = null;
        BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto_3 = null;
        List<OmsEvaObjTargetCycleOset> listOmsEvaObjTargetCycleOset_1 = new ArrayList<>();
        QueryHighMidBaseWorkCycleDataListComRespDto queryHighMidBaseWorkCycleDataListComRespDto_1 = null;
//virtualUsage D3查询规划数据导出内容范围列表(公共)  73844
        QueryPlanningDataExportRangeListComRespDto queryPlanningDataExportRangeListComRespDto = null;
        QueryPlanningDataExportRangeListComReqDto queryPlanningDataExportRangeListComReqDto = new QueryPlanningDataExportRangeListComReqDto();
        queryPlanningDataExportRangeListComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2038904_1_73844
        if (reqDto != null) {
            queryPlanningDataExportRangeListComReqDto.setLevelNumber(reqDto.getLevelNumber());//SimpleFieldAssign//sourceId:2038901_1_73844
            queryPlanningDataExportRangeListComReqDto.setIsLastObjective(reqDto.getIsLastObjective());//SimpleFieldAssign//sourceId:2038902_1_73844
            queryPlanningDataExportRangeListComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2038981_1_73844
            queryPlanningDataExportRangeListComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2038982_1_73844
            queryPlanningDataExportRangeListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2038903_1_73844
        }

        /*D3查询规划数据导出内容范围列表(公共)[10479]   */
        Assert.isNull(queryPlanningDataExportRangeListComReqDto.getCycleId(), "D3查询规划数据导出内容明细列表(公共)-D3查询规划数据导出内容范围列表(公共)-归属周期ID不能为空", false);
        Assert.isNull(queryPlanningDataExportRangeListComReqDto.getParentSubMidCycleType(), "D3查询规划数据导出内容明细列表(公共)-D3查询规划数据导出内容范围列表(公共)-父子中周期类型不能为空", false);
        Assert.isNull(queryPlanningDataExportRangeListComReqDto.getEvaluationTemplateId(), "D3查询规划数据导出内容明细列表(公共)-D3查询规划数据导出内容范围列表(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(queryPlanningDataExportRangeListComReqDto.getSpaceId(), "D3查询规划数据导出内容明细列表(公共)-D3查询规划数据导出内容范围列表(公共)-创建于空间ID不能为空", false);
        queryPlanningDataExportRangeListComRespDto = queryPlanningDataExportRangeListCom(queryPlanningDataExportRangeListComReqDto)/*vcase invoke 同服务,同domain*/;


        queryPlanningDataExportRangeListComRespDto_1 = queryPlanningDataExportRangeListComRespDto;
        if ((queryPlanningDataExportRangeListComRespDto != null && queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList() != null && queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList().size() > 0)) {
            //if(D3查询规划数据导出内容范围列表(公共).规划数据导出明细列表数据集条数 大于 0)  73845

            BatchQueryDeptComRespDto batchQueryDeptComRespDto = null;
            if (queryPlanningDataExportRangeListComRespDto != null) {
                BatchQueryDeptComReqDto batchQueryDeptComReqDto = new BatchQueryDeptComReqDto();
                batchQueryDeptComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2038907_1_73846
                if (queryPlanningDataExportRangeListComRespDto != null && queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList() != null && !CollectionUtil.isEmpty(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList())) {
                    batchQueryDeptComReqDto.setDeptList(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList().stream().map(item -> item.getDeptId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038906_1_73846
                }

                /*D1批量查询部门(公共)[7511]   */
                Assert.isNull(batchQueryDeptComReqDto.getSubjectLifeCycle(), "D3查询规划数据导出内容明细列表(公共)-D1批量查询部门(公共)-主体生命周期不能为空", false);
                batchQueryDeptComRespDto = orgService.batchQueryDeptCom(batchQueryDeptComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                batchQueryDeptComRespDto_1 = batchQueryDeptComRespDto;
            }
            BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto = null;
            if (queryPlanningDataExportRangeListComRespDto != null) {
                BatchQueryInductionRecordListComReqDto batchQueryInductionRecordListComReqDto = new BatchQueryInductionRecordListComReqDto();
                if (queryPlanningDataExportRangeListComRespDto != null && queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList() != null && !CollectionUtil.isEmpty(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList())) {
                    batchQueryInductionRecordListComReqDto.setPerOrgInductionRecordList(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList().stream().map(item -> String.valueOf(item.getPersonLiableInductionRecordId()))
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038909_1_73847
                }

                /*D1-3批量查责任人就职记录列表（公共）[602]   */

                batchQueryInductionRecordListComRespDto = inductionRecordService.batchQueryInductionRecordListCom(batchQueryInductionRecordListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                batchQueryInductionRecordListComRespDto_1 = batchQueryInductionRecordListComRespDto;
            }
            BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto_2 = null;
            if (queryPlanningDataExportRangeListComRespDto != null) {
                BatchQueryInductionRecordListComReqDto batchQueryInductionRecordListComReqDto_1 = new BatchQueryInductionRecordListComReqDto();
                if (queryPlanningDataExportRangeListComRespDto != null && queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList() != null && !CollectionUtil.isEmpty(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList())) {
                    batchQueryInductionRecordListComReqDto_1.setPerOrgInductionRecordList(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList().stream().map(item -> String.valueOf(item.getDirectorInductionRecordId()))
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038912_1_73848
                }

                /*D1-3批量查询主管就职记录列表（公共）[602]   */

                batchQueryInductionRecordListComRespDto_2 = inductionRecordService.batchQueryInductionRecordListCom(batchQueryInductionRecordListComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                batchQueryInductionRecordListComRespDto_3 = batchQueryInductionRecordListComRespDto_2;
            }
            List<OmsEvaObjTargetCycleOset> listOmsEvaObjTargetCycleOset = new ArrayList<>();
            if (queryPlanningDataExportRangeListComRespDto != null) {
                BatchQueryEvaObjTargetCycleTargetReq batchQueryEvaObjTargetCycleTargetReq = new BatchQueryEvaObjTargetCycleTargetReq();
                batchQueryEvaObjTargetCycleTargetReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2038966_1_73853
                if (queryPlanningDataExportRangeListComRespDto != null && queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList() != null && !CollectionUtil.isEmpty(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList())) {
                    batchQueryEvaObjTargetCycleTargetReq.setEvaObjTargetCycleTargetList(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList().stream().map(item -> item.getEvaObjTargetCycleId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038965_1_73853
                }
                if (reqDto != null) {
                    batchQueryEvaObjTargetCycleTargetReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2038970_1_73853
                }

                /*3-3-09-01批量查被评对象目标周期目标列表[2255]   */
                Assert.isNull(batchQueryEvaObjTargetCycleTargetReq.getSubjectLifeCycle(), "D3查询规划数据导出内容明细列表(公共)-3-3-09-01批量查被评对象目标周期目标列表-主体生命周期不能为空", false);
                Assert.isNull(batchQueryEvaObjTargetCycleTargetReq.getEvaluationTemplateId(), "D3查询规划数据导出内容明细列表(公共)-3-3-09-01批量查被评对象目标周期目标列表-冗余评价模板ID不能为空", false);
                listOmsEvaObjTargetCycleOset = mOmsEvaObjTargetCycleOsetService.batchQueryEvaObjTargetCycleTarget(batchQueryEvaObjTargetCycleTargetReq)/*vcase invoke 本地 method 方法调用;*/;


                listOmsEvaObjTargetCycleOset_1 = listOmsEvaObjTargetCycleOset;
            }
            QueryHighMidBaseWorkCycleDataListComRespDto queryHighMidBaseWorkCycleDataListComRespDto = null;
            if (queryPlanningDataExportRangeListComRespDto != null) {
                QueryHighMidBaseWorkCycleDataListComReqDto queryHighMidBaseWorkCycleDataListComReqDto = new QueryHighMidBaseWorkCycleDataListComReqDto();
                queryHighMidBaseWorkCycleDataListComReqDto.setIsNewData("TRUE");//sourceId:2038977_1_73854
                queryHighMidBaseWorkCycleDataListComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2038979_1_73854
                if (queryPlanningDataExportRangeListComRespDto != null && queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList() != null && !CollectionUtil.isEmpty(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList())) {
                    queryHighMidBaseWorkCycleDataListComReqDto.setEvaObjTargetCycleList(queryPlanningDataExportRangeListComRespDto.getPlanningExportDetailList().stream().map(item -> item.getEvaObjTargetCycleId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:2038971_1_73854
                }
                if (queryPlanningDataExportRangeListComRespDto != null) {
                    queryHighMidBaseWorkCycleDataListComReqDto.setCycleId(queryPlanningDataExportRangeListComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:2038972_1_73854
                }
                if (reqDto != null) {
                    queryHighMidBaseWorkCycleDataListComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2038973_1_73854
                    queryHighMidBaseWorkCycleDataListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2038974_1_73854
                }

                /*D4-查询高中基工作周期使用标准数据列表(公共)[6043]   */
                Assert.isNull(queryHighMidBaseWorkCycleDataListComReqDto.getParentSubMidCycleType(), "D3查询规划数据导出内容明细列表(公共)-D4-查询高中基工作周期使用标准数据列表(公共)-父子中周期类型不能为空", false);
                Assert.isNull(queryHighMidBaseWorkCycleDataListComReqDto.getIsNewData(), "D3查询规划数据导出内容明细列表(公共)-D4-查询高中基工作周期使用标准数据列表(公共)-是否归属周期最新数据不能为空", false);
                Assert.isNull(queryHighMidBaseWorkCycleDataListComReqDto.getDataUsageSceneCode(), "D3查询规划数据导出内容明细列表(公共)-D4-查询高中基工作周期使用标准数据列表(公共)-数据业务场景不能为空", false);
                Assert.isNull(queryHighMidBaseWorkCycleDataListComReqDto.getEvaluationTemplateId(), "D3查询规划数据导出内容明细列表(公共)-D4-查询高中基工作周期使用标准数据列表(公共)-冗余评价模板ID不能为空", false);
                queryHighMidBaseWorkCycleDataListComRespDto = fwCalcStandardDataClient.queryHighMidBaseWorkCycleDataListCom(queryHighMidBaseWorkCycleDataListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                queryHighMidBaseWorkCycleDataListComRespDto_1 = queryHighMidBaseWorkCycleDataListComRespDto;
            }
        }
        QueryPlanningDataExportDetailListComRespDto retData = new QueryPlanningDataExportDetailListComRespDto();
        //数据集融合  MoreListToOneSource
        if (queryPlanningDataExportRangeListComRespDto_1 != null && !CollectionUtil.isEmpty(queryPlanningDataExportRangeListComRespDto_1.getPlanningExportDetailList())) {
            for (PlanningExportDetailDto planningExportDetailDto : queryPlanningDataExportRangeListComRespDto_1.getPlanningExportDetailList()) {
                PlanningExportDetailDto retElm = new PlanningExportDetailDto();
                if (queryPlanningDataExportRangeListComRespDto_1 != null) {
                    retElm.setEvaluationTempName(planningExportDetailDto.getEvaluationTempName());//SimpleFieldAssign//sourceId:431402_2
                    retElm.setRootTargetCategoryName(planningExportDetailDto.getRootTargetCategoryName());//SimpleFieldAssign//sourceId:431403_2
                    retElm.setLastTargetCategoryName(planningExportDetailDto.getLastTargetCategoryName());//SimpleFieldAssign//sourceId:431404_2
                    retElm.setObjectiveShortName(planningExportDetailDto.getObjectiveShortName());//SimpleFieldAssign//sourceId:431405_2
                }
                retData.getPlanningExportDetailList().add(retElm);
                if (batchQueryDeptComRespDto_1 != null) {
                    for (DeptDto deptDto : batchQueryDeptComRespDto_1.getDeptList()) {
                        if (deptDto.getDeptId().equals(planningExportDetailDto.getDeptId())) {
                            if (batchQueryDeptComRespDto_1 != null) {
                                retElm.setDeptShortName(deptDto.getDeptShortName());//SimpleFieldAssign//sourceId:431409_2
                            }
                        }
                    }
                }

                if (batchQueryInductionRecordListComRespDto_1 != null) {
                    for (PerOrgInductionRecordDto perOrgInductionRecordDto : batchQueryInductionRecordListComRespDto_1.getPerOrgInductionRecordList()) {
                        if (perOrgInductionRecordDto.getInductionRecordId().equals(planningExportDetailDto.getPersonLiableInductionRecordId())) {
                            if (batchQueryInductionRecordListComRespDto_1 != null) {
                                retElm.setPersonLiableIdCardName(perOrgInductionRecordDto.getIdCardName());//SimpleFieldAssign//sourceId:431410_2
                            }
                        }
                    }
                }

                if (batchQueryInductionRecordListComRespDto_3 != null) {
                    for (PerOrgInductionRecordDto perOrgInductionRecordDto : batchQueryInductionRecordListComRespDto_3.getPerOrgInductionRecordList()) {
                        if (perOrgInductionRecordDto.getInductionRecordId().equals(planningExportDetailDto.getDirectorInductionRecordId())) {
                            if (batchQueryInductionRecordListComRespDto_3 != null) {
                                retElm.setDirectorIdCardName(perOrgInductionRecordDto.getIdCardName());//SimpleFieldAssign//sourceId:431411_2
                            }
                        }
                    }
                }

                if (listOmsEvaObjTargetCycleOset_1 != null && !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleOset_1)) {
                    for (OmsEvaObjTargetCycleOset omsEvaObjTargetCycleOset : listOmsEvaObjTargetCycleOset_1) {
                        if (omsEvaObjTargetCycleOset.getEvaObjTargetCycleId().equals(planningExportDetailDto.getEvaObjTargetCycleId())) {
                            retElm.setShowTargetValue(omsEvaObjTargetCycleOset.getShowTargetValue());//SimpleFieldAssign//sourceId:431563_2
                            retElm.setUnit(omsEvaObjTargetCycleOset.getUnit());//SimpleFieldAssign//sourceId:431564_2
                        }
                    }
                }

                if (queryHighMidBaseWorkCycleDataListComRespDto_1 != null) {
                    for (StandardDataDto standardDataDto : queryHighMidBaseWorkCycleDataListComRespDto_1.getStandardDataList()) {
                        if (standardDataDto.getEntityId().equals(planningExportDetailDto.getEvaObjTargetCycleId())) {
                            if (queryHighMidBaseWorkCycleDataListComRespDto_1 != null) {
                                retElm.setActualValue(standardDataDto.getActualValue());//SimpleFieldAssign//sourceId:431565_2
                                retElm.setActualValueUnit(standardDataDto.getActualValueUnit());//SimpleFieldAssign//sourceId:431566_2
                                retElm.setProgressValue(standardDataDto.getProgressValue());//SimpleFieldAssign//sourceId:431567_2
                                retElm.setProgressValueUnit(standardDataDto.getProgressValueUnit());//SimpleFieldAssign//sourceId:431568_2
                            }
                        }
                    }
                }

            }
        }//sourceId:2038917_1


        return retData;
    }

    /**
     * D3分析目标内容生命周期(公共)[10521]
     * gen by moon at 4/7/2025, 10:57:30 PM
     */
    @Trace(operationName = "D3分析目标内容生命周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisTargetContentSubjectLifeComRespDto analysisTargetContentSubjectLifeCom(AnalysisTargetContentSubjectLifeComReqDto reqDto) {


        ImplementElevenReceivingFieldRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getTableTypeCode() != null && reqDto.getTableTypeCode().equals("OMS_TARGET_OBJECTIVE"))) {
            //if(D3分析目标内容生命周期(公共).内容表类型编码 等于 指标表)  74014

            OmsTargetObjective omsTargetObjective = null;
            QueryTargetObjectiveDetailReq queryTargetObjectiveDetailReq = new QueryTargetObjectiveDetailReq();
            queryTargetObjectiveDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2044974_1_74016
            if (reqDto != null) {
                queryTargetObjectiveDetailReq.setObjectiveId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2044973_1_74016
            }

            /*3-3-03查询指标详情[9411]   */
            Assert.isNull(queryTargetObjectiveDetailReq.getObjectiveId(), "D3分析目标内容生命周期(公共)-3-3-03查询指标详情-指标ID不能为空", false);
            Assert.isNull(queryTargetObjectiveDetailReq.getSpaceId(), "D3分析目标内容生命周期(公共)-3-3-03查询指标详情-创建于空间ID不能为空", false);
            omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjectiveDetail(queryTargetObjectiveDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: receptionService
            ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
            if (omsTargetObjective != null) {
                ImplementElevenReceivingFieldReqDto receptionServiceReq = new ImplementElevenReceivingFieldReqDto();
                if (omsTargetObjective != null) {
                    receptionServiceReq.setSubjectLifeCycle(omsTargetObjective.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2045434_1_74018
                }

                /*M3接收出参字段：主体生命周期[9482]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getSubjectLifeCycle(), "D3分析目标内容生命周期(公共)-M3接收出参字段：主体生命周期-主体生命周期不能为空", false);
                receptionServiceRes = nbTargetContCom.implementElevenReceivingField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((reqDto != null && reqDto.getTableTypeCode() != null && reqDto.getTableTypeCode().equals("OMS_TARGET_CATEGORY"))) {
            //elseif(D3分析目标内容生命周期(公共).内容表类型编码 等于 目标分类表)  74015

            OmsTargetCategory omsTargetCategory = null;
            QueryTargetCatDetailReq queryTargetCatDetailReq = new QueryTargetCatDetailReq();
            if (reqDto != null) {
                queryTargetCatDetailReq.setTargetCategoryId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2044976_1_74017
            }

            /*3-3-02查目标分类详情[2595]   */
            Assert.isNull(queryTargetCatDetailReq.getTargetCategoryId(), "D3分析目标内容生命周期(公共)-3-3-02查目标分类详情-目标分类ID不能为空", false);
            omsTargetCategory = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: receptionService
            ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
            if (omsTargetCategory != null) {
                ImplementElevenReceivingFieldReqDto receptionServiceReq_1 = new ImplementElevenReceivingFieldReqDto();
                if (omsTargetCategory != null) {
                    receptionServiceReq_1.setSubjectLifeCycle(omsTargetCategory.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2045434_1_74019
                }

                /*M3接收出参字段：主体生命周期[9482]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getSubjectLifeCycle(), "D3分析目标内容生命周期(公共)-M3接收出参字段：主体生命周期-主体生命周期不能为空", false);
                receptionServiceRes_2 = nbTargetContCom.implementElevenReceivingField(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        } else if ((reqDto != null && reqDto.getTableTypeCode() != null && reqDto.getTableTypeCode().equals("OMS_TARGET"))) {
            //elseif(D3分析目标内容生命周期(公共).内容表类型编码 等于 目标表)  74020

            OmsTarget omsTarget = null;
            QueryTargetDetailReq queryTargetDetailReq = new QueryTargetDetailReq();
            if (reqDto != null) {
                queryTargetDetailReq.setTargetId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2045459_1_74021
            }

            /*3-3-01查目标详情[2488]   */
            Assert.isNull(queryTargetDetailReq.getTargetId(), "D3分析目标内容生命周期(公共)-3-3-01查目标详情-目标ID不能为空", false);
            omsTarget = mOmsTargetService.queryTargetDetail(queryTargetDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: receptionService
            ImplementElevenReceivingFieldRespDto receptionServiceRes_3 = null;
            if (omsTarget != null) {
                ImplementElevenReceivingFieldReqDto receptionServiceReq_2 = new ImplementElevenReceivingFieldReqDto();
                if (omsTarget != null) {
                    receptionServiceReq_2.setSubjectLifeCycle(omsTarget.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2045434_1_74022
                }

                /*M3接收出参字段：主体生命周期[9482]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_2.getSubjectLifeCycle(), "D3分析目标内容生命周期(公共)-M3接收出参字段：主体生命周期-主体生命周期不能为空", false);
                receptionServiceRes_3 = nbTargetContCom.implementElevenReceivingField(receptionServiceReq_2);


                receptionServiceRes_1 = receptionServiceRes_3;
            }
        }
        AnalysisTargetContentSubjectLifeComRespDto retData = new AnalysisTargetContentSubjectLifeComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setSubjectLifeCycle(receptionServiceRes_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2045462_1
        }


        return retData;
    }
///**
//   * D3查询指标详情(公共)[9412]
//   * gen by moon at 4/19/2024, 11:00:29 PM
//   */
//  @Trace(operationName = "D3查询指标详情(公共)")
//  @Tags({@Tag(key = "参数",value = "arg[0]"),
//            @Tag(key = "返回值",value = "returnedObj")})
//  @Transactional(rollbackFor=Exception.class)
//  @Override
//  public QueryTargetObjectiveDetailComRespDto queryTargetObjectiveDetailCom(QueryTargetObjectiveDetailComReqDto reqDto){
//
//
//      OmsTargetObjective omsTargetObjective_1 =null;
////步骤0: 3-3-03查询指标详情 - queryTargetObjectiveDetail
//     OmsTargetObjective omsTargetObjective = null;
//    QueryTargetObjectiveDetailReq queryTargetObjectiveDetailReq=new QueryTargetObjectiveDetailReq();
//  if(reqDto!=null){
//      queryTargetObjectiveDetailReq.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1737920_1
//queryTargetObjectiveDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1737921_1
//queryTargetObjectiveDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1737922_1
//queryTargetObjectiveDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1737923_1
//    }
//
//    /*3-3-03查询指标详情[9411]   */
//    Assert.isNull(queryTargetObjectiveDetailReq.getEvaluationTemplateId(),"D3查询指标详情(公共)-3-3-03查询指标详情-冗余评价模板ID不能为空",false);
//      omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjectiveDetail(queryTargetObjectiveDetailReq)/*vcase invoke 本地 method 方法调用;*/;
//
//
//      omsTargetObjective_1 = omsTargetObjective;
//
//QueryTargetObjectiveDetailComRespDto retData = new QueryTargetObjectiveDetailComRespDto();
//  if(omsTargetObjective_1!=null){
//      retData.setObjectiveId(omsTargetObjective_1.getObjectiveId());//SimpleFieldAssign//sourceId:1737933_1
//retData.setTargetValueType(omsTargetObjective_1.getTargetValueType());//SimpleFieldAssign//sourceId:1737934_1
//retData.setIsLeft(omsTargetObjective_1.getIsLeft());//SimpleFieldAssign//sourceId:1737935_1
//retData.setUnit(omsTargetObjective_1.getUnit());//SimpleFieldAssign//sourceId:1737936_1
//retData.setDigitalUnit(omsTargetObjective_1.getDigitalUnit());//SimpleFieldAssign//sourceId:1737937_1
//    }
//
//
//
//
//return retData;
//  }
    //
}
